protected Validator comeOnHibernateValidator(Supplier<VaConfigSetupper> configSetupperSupplier) {
    if (isSuppressHibernateValidatorCache()) {
        return createHibernateValidator(configSetupperSupplier);
    } else { // basically here
        if (cachedValidator != null) {
            return cachedValidator;
        }
        synchronized (ActionValidator.class) {
            if (cachedValidator != null) {
                return cachedValidator;
            }
            cachedValidator = createHibernateValidator(configSetupperSupplier);
            return cachedValidator;
        }
    }
}
 

@Before
public void setupBefore() {

    // BeanValidatorの式言語の実装を独自のものにする。
    ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();
    Validator validator = validatorFactory.usingContext()
            .messageInterpolator(new MessageInterpolatorAdapter(
                    // メッセージリソースの取得方法を切り替える
                    new ResourceBundleMessageResolver(),

                    // EL式の処理を切り替える
                    new MessageInterpolator(new ExpressionLanguageJEXLImpl())))
            .getValidator();

    // BeanValidationのValidatorを渡す
    this.sheetBeanValidator = new SheetBeanValidator(validator);

    this.errorFormatter = new SheetErrorFormatter();

}
 

/**
 * 手动校验对象，很多场景下需要使用这种方式
 */
@Test
public void check_person_manually() {

    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    Validator validator = factory.getValidator();
    Person person = new Person();
    person.setSex("Man22");
    person.setClassId("82938390");
    person.setEmail("SnailClimb");
    Set<ConstraintViolation<Person>> violations = validator.validate(person);
    //output:
    //email 格式不正确
    //name 不能为空
    //sex 值不在可选范围
    for (ConstraintViolation<Person> constraintViolation : violations) {
        System.out.println(constraintViolation.getMessage());
    }
}
 

@Test
   public void shouldNotValidateWhenFirstNameEmpty() {

LocaleContextHolder.setLocale(Locale.ENGLISH);
       Person person = new Person();
       person.setFirstName("");
       person.setLastName("smith");

       Validator validator = createValidator();
       Set<ConstraintViolation<Person>> constraintViolations = validator.validate(person);

       Assert.assertEquals(1, constraintViolations.size());
       ConstraintViolation<Person> violation =  constraintViolations.iterator().next();
       assertThat(violation.getPropertyPath().toString()).isEqualTo("firstName");
       assertThat(violation.getMessage()).isEqualTo("may not be empty");
   }
 

@Override public Statement apply(final Statement base, Description description) {
  return new Statement() {
    @Override public void evaluate() throws Throwable {
      File yamlFile = new File(Resources.getResource("keywhiz-test.yaml").getFile());
      Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
      ObjectMapper objectMapper = KeywhizService.customizeObjectMapper(Jackson.newObjectMapper());
      KeywhizConfig config = new YamlConfigurationFactory<>(KeywhizConfig.class, validator, objectMapper, "dw")
          .build(yamlFile);

      DataSource dataSource = config.getDataSourceFactory()
          .build(new MetricRegistry(), "db-migrations");

      Flyway flyway = Flyway.configure().dataSource(dataSource).locations(config.getMigrationsDir()).table(config.getFlywaySchemaTable()).load();
      flyway.clean();
      flyway.migrate();

      DSLContext dslContext = DSLContexts.databaseAgnostic(dataSource);
      DbSeedCommand.doImport(dslContext);

      base.evaluate();
    }
  };
}
 

@Test
public void shouldNotValidateWhenFirstNameEmpty() {

	LocaleContextHolder.setLocale(Locale.ENGLISH);
	Person person = new Person();
	person.setFirstName("");
	person.setLastName("smith");

	Validator validator = createValidator();
	Set<ConstraintViolation<Person>> constraintViolations = validator
			.validate(person);

	assertThat(constraintViolations.size()).isEqualTo(1);
	ConstraintViolation<Person> violation = constraintViolations.iterator().next();
	assertThat(violation.getPropertyPath().toString()).isEqualTo("firstName");
	assertThat(violation.getMessage()).isEqualTo("must not be empty");
}
 

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 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);
}
 

@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();
}
 

@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());
	}
}
 

@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;
}
 

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()));
}
 

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;
    }
}
 

public IntegrationHandler(final DataManager dataMgr, final OpenShiftService openShiftService,
                          final Validator validator, final Inspectors inspectors,
                          final EncryptionComponent encryptionSupport, final APIGenerator apiGenerator,
                          final IntegrationOverviewHelper integrationOverviewHelper) {
    super(dataMgr);
    this.openShiftService = openShiftService;
    this.validator = validator;
    this.inspectors = inspectors;
    this.encryptionSupport = encryptionSupport;
    this.apiGenerator = apiGenerator;
    this.integrationOverviewHelper = integrationOverviewHelper;
}
 

/**
 * Initializes the validator, and registers it as an OSGi service (if the bundle context is set).
 *
 * @return the validator.
 */
@Validate
public Validator initialize() {
    // configure and build an instance of ValidatorFactory
    ProviderSpecificBootstrap<HibernateValidatorConfiguration> validationBootStrap = javax.validation.Validation
            .byProvider(HibernateValidator.class);

    // bootstrap to properly resolve in an OSGi environment
    validationBootStrap.providerResolver(new HibernateValidationProviderResolver());

    HibernateValidatorConfiguration configure = validationBootStrap.configure().messageInterpolator(interpolator);
    interpolator.setDefaultInterpolator(configure.getDefaultMessageInterpolator());

    // now that we've done configuring the ValidatorFactory, let's build it
    ValidatorFactory validatorFactory = configure.buildValidatorFactory();

    // retrieve a unique validator.
    Validator validator = validatorFactory.getValidator();

    // Register the validator.
    if (context != null) {
        registration = context.registerService(Validator.class, new WrappedValidator(validator), null);
        factoryRegistration = context.registerService(ValidatorFactory.class, validatorFactory, null);
    }

    return validator;
}
 

/**
 * Validates the {@link FbBotMillResponse}.
 *
 * @param response
 *            the response
 * @return true if the response is valid, false otherwise.
 */
protected boolean validate(FbBotMillResponse response) {
	// If validations are not enabled, returns true.
	if (!FbBotMillContext.getInstance().isValidationEnabled()) {
		return true;
	}

	boolean valid = true;
	ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
	Validator validator = factory.getValidator();
	Set<ConstraintViolation<FbBotMillResponse>> violations = validator
			.validate(response);
	for (ConstraintViolation<FbBotMillResponse> v : violations) {
		valid = false;
		logger.error(
				"FbBotMillResponse validation error. Message: [{}] Value: [{}], Class: [{}], Field: [{}]",
				v.getMessage(), v.getInvalidValue(), v.getRootBean(),
				v.getPropertyPath());
	}

	if (valid == false) {
		// Sends the constraint violations through the callback.
		List<FbBotMillMonitor> registeredMonitors = FbBotMillContext
				.getInstance().getRegisteredMonitors();
		for (FbBotMillMonitor monitor : registeredMonitors) {
			monitor.onValidationError(response, violations);
		}
	}

	return valid;
}
 

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

    this.validator = validator;
}
 

@AroundInvoke
public Object validateMethodInvocation(InvocationContext ctx) throws Exception {

    Object resource = ctx.getTarget();
    Method method = ctx.getMethod();

    log.log(Level.FINE, "Starting validation for controller method: {0}#{1}", new Object[]{
            resource.getClass().getName(), method.getName()
    });

    Validator validator = validatorFactory.getValidator();
    ExecutableValidator executableValidator = validator.forExecutables();

    // validate controller property parameters
    processViolations(ctx,
            validator.validate(resource)
    );

    // validate controller method parameters
    processViolations(ctx,
            executableValidator.validateParameters(resource, method, ctx.getParameters())
    );

    // execute method
    Object result = ctx.proceed();

    // TODO: Does this make sense? Nobody will be able to handle these. Remove?
    processViolations(ctx,
            executableValidator.validateReturnValue(resource, method, result)
    );

    return result;

}
 

public static <T> Map<String, String> validate(T t, Class... groups) {
    Validator validator = validatorFactory.getValidator();
    Set validateResult = validator.validate(t, groups);
    if (validateResult.isEmpty()) {
        return Collections.emptyMap();
    } else {
        LinkedHashMap errors = new LinkedHashMap<>();
        Iterator iterator = validateResult.iterator();
        while (iterator.hasNext()) {
            ConstraintViolation violation = (ConstraintViolation)iterator.next();
            errors.put(violation.getPropertyPath().toString(), violation.getMessage());
        }
        return errors;
    }
}
 

private void validateMatchingDataset(Validator validator, MatchingDataset matchingDataset) throws MatchingDatasetArgumentValidationError {
    Set<ConstraintViolation<MatchingDataset>> validations = validator.validate(matchingDataset);
    if(!validations.isEmpty()) {
        final String errors = validations
                .stream().map(violation -> ConstraintMessage.getMessage(violation, Invocable.create(request -> null)))
                .collect(Collectors.joining(", "));

        throw new MatchingDatasetArgumentValidationError(String.format("Matching Dataset argument was not valid: %s", errors));
    }
}
 

@Test
public void testCPDataLevel(){
    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    Validator validator = factory.getValidator();

    Set<ConstraintViolation<T212Map>> e2005 = validator.validate(cpDataLevel,Default.class,
            T212MapLevelGroup.CpDataLevel.class, VersionGroup.V2005.class);
    assertTrue(e2005.isEmpty());
    Set<ConstraintViolation<T212Map>> e2017 = validator.validate(cpDataLevel,Default.class,
            T212MapLevelGroup.CpDataLevel.class, VersionGroup.V2017.class);
    assertTrue(e2017.isEmpty());
}
 

@SuppressWarnings("Duplicates")
@Test
public void test(){
    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    Validator validator = factory.getValidator();

    T212Map t212Map = T212Map.createDataLevel(map);

    Set<ConstraintViolation<T212Map>> e1 = validator.validate(t212Map,
            Default.class);
    assertEquals(e1.size(),1);
}
 

private <T> List<BeanValidationErrorDTO> beanValidation(T bean) {

        try (ValidatorFactory factory = Validation.buildDefaultValidatorFactory()) {
        	Validator validator = factory.getValidator();
        	
        	Set<ConstraintViolation<T>> violations = validator.validate(bean);
        	
        	return violations.stream().map(v -> {
				return new BeanValidationErrorDTO(v.getPropertyPath().toString(), v.getMessage());
			}).collect(Collectors.toList());
        }
   }
 

/**
 * Set the JSR-303 Validator to delegate to for validating methods.
 * <p>Default is the default ValidatorFactory's default Validator.
 */
public void setValidator(Validator validator) {
	// Unwrap to the native Validator with forExecutables support
	if (validator instanceof LocalValidatorFactoryBean) {
		this.validator = ((LocalValidatorFactoryBean) validator).getValidator();
	}
	else if (validator instanceof SpringValidatorAdapter) {
		this.validator = validator.unwrap(Validator.class);
	}
	else {
		this.validator = validator;
	}
}
 

@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());
}
 

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

    this.validator = validator;
}
 

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

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();
}
 

@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();
        }
    }
}