Examples of MethodValidator

br.com.caelum.vraptor.validator.beanvalidation.MethodValidator
Validate method parameters using Bean Validation. The method will be validated if any parameter contains a Bean Validation annotation. @author Otávio Scherer Garcia @author Rodrigo Turini @since 3.5.1
org.apache.bval.jsr303.extensions.MethodValidator
Description: Appendix C. Proposal for method-level validation. This interface contains the APIs added to javax.validation.Validator. It can be removed as soon as the Validator interface contains these methods. The extension is not a part of the JSR303 core specification yet, but could be in a future revision.
You can access the extension via the use of the Validator.unwrap() method.
org.hibernate.validator.MethodValidator
rg/en/jsr/detail?id=303">JSR 303: Bean Validation, Appendix C ("Proposal for method-level validation").

The purpose of this API is to provide a facility for the Programming by Contract approach for systems design based on the concepts defined by the Bean Validation API. More specifically this means that any Bean Validation constraints (built-in as well as custom constraints) can be used to describe
- any preconditions that must be met before a method invocation (by annotating method parameters with constraints) and
- any postconditions that are guaranteed after a method invocation (by annotating methods).
These constraints can relate to the parameters/return values themselves but it is also possible to trigger a recursive validation of these values using the special {@link Valid} annotation. If for instance considering the methoddeclaration
```
 @NotNull @Valid Customer findCustomerByName(@NotNull @Size(min = 5) String name) { // ... } 
```
the following conditions would hold (provided the method validation is triggered automatically by some integration layer, see below):
- The name parameter is guaranteed to be not null and at least 5 characters long. In especially it is not necessary that the implementor of the method performs these checks manually.
- It is guaranteed that the call yields a non-null object, which itself is valid with respect to all the bean validation constraints applying for it's type. In especially it is not necessary for the caller to perform these checks manually.
This service only copes with the actual validation of method parameters/return values itself, but not with the invocation of such a validation. It is expected that this invocation is triggered by an integration layer using AOP or similar method interception facilities such as JDK's {@link Proxy} API or CDI ( "JSR 299: Contexts and Dependency Injection for the Java^TM EE platform" ).

Such an integration layer would typically intercept each method call to be validated, validate the call's parameters, proceed with the method invocation and finally validate the invocation's return value. If any of the validation steps yields a non-empty set of constraint violations the integration layer would typically throw a {@link MethodConstraintViolationException} wrappingthese violations which in turn guarantees that the call flow only arrives at the method's implementation respectively call site if all pre- respectively postconditions are fulfilled.

MethodValidator instances are obtained by {@link Validator#unwrap(Class) unwrapping} a {@link Validator} object:
```
 Validator validator = ...; MethodValidator methodValidator = validator.unwrap(MethodValidator.class); 
```
Method level validation is (currently) a proprietary feature of Hibernate Validator (HV), so the unwrapped Validator instance must be HV's implementation. In case there are multiple Bean Validation implementations on the classpath, this can be done be explicitly choosing HV as validation provider:
```
 MethodValidator methodValidator = Validation.byProvider(HibernateValidator.class) .configure() .buildValidatorFactory() .getValidator() .unwrap(MethodValidator.class); 
```
If not stated otherwise, none of this interface's methods allow null as parameter value.
@author Gunnar Morling
org.hibernate.validator.method.MethodValidator
rg/en/jsr/detail?id=303">JSR 303: Bean Validation, Appendix C ("Proposal for method-level validation").

The purpose of this API is to provide a facility for the Programming by Contract approach to program design based on the concepts defined by the Bean Validation API. More specifically this means that any Bean Validation constraints (built-in as well as custom constraints) can be used to describe
- any preconditions that must be met before a method may legally be invoked (by annotating method parameters with constraints) and
- any postconditions that are guaranteed after a method invocation returns (by annotating methods).
These constraints may be declared directly on a method's parameters and/or return values. Alternatively, by annotating method parameters/return values with the special {@link javax.validation.Valid}annotation a recursive validation of those parameters/return values against the constraints defined on their types can be triggered. Consider for instance the method declaration
```
 @NotNull @Valid Customer findCustomerByName(@NotNull @Size(min = 5) String name) { // ... } 
```
Here, the validation engine will check for the following pre- and postconditions (provided the method validation is triggered automatically by some integration layer, see below):
- The name parameter is guaranteed to be not null and at least 5 characters long. In particular it is not necessary for the implementor of this method to perform these checks manually.
- It is guaranteed that the call yields a non-null object, which itself is valid according to all the bean validation constraints declared on its type. In particular it is not necessary for the caller to perform these checks manually.
This service only deals with the actual validation of method parameters/return values itself, but not with the invocation of such a validation. It is expected that this invocation is triggered by an integration layer using AOP or similar method interception facilities such as the JDK's {@link java.lang.reflect.Proxy} API or CDI ( "JSR 299: Contexts and Dependency Injection for the Java^TM EE platform" ).

Such an integration layer would typically intercept each method call to be validated, validate the call's parameters, proceed with the method invocation and finally validate the invocation's return value. If any of the validation steps yields a non-empty set of constraint violations the integration layer would typically throw a {@link MethodConstraintViolationException} wrappingthese violations which in turn guarantees that the call flow only arrives at the method's implementation respectively call site if all pre- respectively postconditions are fulfilled.

MethodValidator instances are obtained by {@link javax.validation.Validator#unwrap(Class) unwrapping} a {@link javax.validation.Validator} object:
```
 Validator validator = ...; MethodValidator methodValidator = validator.unwrap(MethodValidator.class); 
```
Method level validation is (currently) a proprietary feature of Hibernate Validator (HV), so the unwrapped Validator instance must be HV's implementation. In case there are multiple Bean Validation implementations on the classpath, this can be done be explicitly choosing HV as validation provider:
```
 MethodValidator methodValidator = Validation.byProvider(HibernateValidator.class) .configure() .buildValidatorFactory() .getValidator() .unwrap(MethodValidator.class); 
```
If not stated otherwise, none of this interface's methods allow null as parameter value.
@author Gunnar Morling
org.junit.internal.runners.MethodValidator

Examples of br.com.caelum.vraptor.validator.beanvalidation.MethodValidator

    assertThat(validator.getErrors(), hasSize(2));
    assertThat(validator.getErrors(), containsInAnyOrder(expected));
  }


  private MethodValidator getMethodValidator() {
    return new MethodValidator(new MockInstanceImpl<Locale>(new Locale("pt", "br")), interpolator, validatorFactory.getValidator());
  }

View Full Code Here

Examples of org.apache.bval.jsr303.extensions.MethodValidator

     */
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Validate validate = invocation.getMethod().getAnnotation(Validate.class);


        Validator validator = this.validatorProvider.get();
        MethodValidator methodValidator = validator.unwrap(MethodValidator.class);


        Set<ConstraintViolation<?>> constraintViolations = new HashSet<ConstraintViolation<?>>();
        Class<?> clazz = invocation.getMethod().getDeclaringClass();
        Method method = invocation.getMethod();
        Object[] arguments = invocation.getArguments();
        Class<?>[] groups = validate.groups();


        constraintViolations.addAll(methodValidator.validateParameters(clazz,
                method,
                arguments,
                groups));


        if (!constraintViolations.isEmpty()) {
            throw getException(new ConstraintViolationException("Validation error when calling method '"
                        + method
                        + "' with arguments "
                        + Arrays.deepToString(arguments), constraintViolations),
                    validate.rethrowExceptionsAs());
        }


        Object returnedValue = invocation.proceed();


        if (validate.validateReturnedValue()) {
            constraintViolations.addAll(methodValidator.validateReturnedValue(clazz, method, returnedValue, groups));
            if (!constraintViolations.isEmpty()) {
                throw getException(new ConstraintViolationException("Method '"
                        + method
                        + "' returned a not valid value "
                        + returnedValue, constraintViolations), validate.rethrowExceptionsAs());

View Full Code Here

Examples of org.apache.bval.jsr303.extensions.MethodValidator

        throws Throwable
    {
        Validate validate = invocation.getMethod().getAnnotation( Validate.class );


        Validator validator = validatorFactory.getValidator();
        MethodValidator methodValidator = validator.unwrap( MethodValidator.class );


        Set<ConstraintViolation<?>> constraintViolations = new HashSet<ConstraintViolation<?>>();
        Class<?> clazz = invocation.getMethod().getDeclaringClass();
        Method method = invocation.getMethod();
        Object[] arguments = invocation.getArguments();
        Class<?>[] groups = validate.groups();


        constraintViolations.addAll( methodValidator.validateParameters( clazz, method, arguments, groups ) );


        if ( !constraintViolations.isEmpty() )
        {
            throw getException( new ConstraintViolationException( format( "Validation error when calling method '%s' with arguments %s",
                                                                          method,
                                                                          deepToString( arguments ) ),
                                                                  constraintViolations ),
                                validate.rethrowExceptionsAs(),
                                validate.exceptionMessage(),
                                arguments );
        }


        Object returnedValue = invocation.proceed();


        if ( validate.validateReturnedValue() )
        {
            constraintViolations.addAll( methodValidator.validateReturnedValue( clazz, method, returnedValue, groups ) );


            if ( !constraintViolations.isEmpty() )
            {
                throw getException( new ConstraintViolationException( format( "Method '%s' returned a not valid value %s",
                                                                              method,

View Full Code Here

Examples of org.apache.bval.jsr303.extensions.MethodValidator

    /**
     * {@inheritDoc}
     */
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Validate validate = invocation.getMethod().getAnnotation(Validate.class);
        MethodValidator methodValidator = this.validator.unwrap(MethodValidator.class);


        Set<ConstraintViolation<?>> constraintViolations = new HashSet<ConstraintViolation<?>>();
        Class<?> clazz = invocation.getMethod().getDeclaringClass();
        Method method = invocation.getMethod();
        Object[] arguments = invocation.getArguments();
        Class<?>[] groups = validate.groups();


        constraintViolations.addAll(methodValidator.validateParameters(clazz,
                method,
                arguments,
                groups));


        if (!constraintViolations.isEmpty()) {
            throw new ConstraintViolationException("Validation error when calling method '"
                    + method
                    + "' with arguments "
                    + Arrays.deepToString(arguments), constraintViolations);
        }


        Object returnedValue = invocation.proceed();


        if (validate.validateReturnedValue()) {
            constraintViolations.addAll(methodValidator.validateReturnedValue(clazz, method, returnedValue, groups));
            if (!constraintViolations.isEmpty()) {
                throw new ConstraintViolationException("Method '"
                        + method
                        + "' returned a not valid value "
                        + returnedValue, constraintViolations);

View Full Code Here

Examples of org.apache.bval.jsr303.extensions.MethodValidator

     */
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Validate validate = invocation.getMethod().getAnnotation(Validate.class);


        Validator validator = this.validatorFactory.getValidator();
        MethodValidator methodValidator = validator.unwrap(MethodValidator.class);


        Set<ConstraintViolation<?>> constraintViolations = new HashSet<ConstraintViolation<?>>();
        Class<?> clazz = invocation.getMethod().getDeclaringClass();
        Method method = invocation.getMethod();
        Object[] arguments = invocation.getArguments();
        Class<?>[] groups = validate.groups();


        constraintViolations.addAll(methodValidator.validateParameters(clazz,
                method,
                arguments,
                groups));


        if (!constraintViolations.isEmpty()) {
            throw getException(new ConstraintViolationException(
                    String.format("Validation error when calling method '%s' with arguments %s",
                            method,
                            Arrays.deepToString(arguments)),
                    constraintViolations),
                    validate.rethrowExceptionsAs(),
                    validate.exceptionMessage(),
                    arguments);
        }


        Object returnedValue = invocation.proceed();


        if (validate.validateReturnedValue()) {
            constraintViolations.addAll(methodValidator.validateReturnedValue(clazz, method, returnedValue, groups));


            if (!constraintViolations.isEmpty()) {
                throw getException(new ConstraintViolationException(
                        String.format("Method '%s' returned a not valid value %s",
                                method,

View Full Code Here

Examples of org.hibernate.validator.MethodValidator

  //Match any public methods in a class annotated with @AutoValidating
  @Around("execution(public * *(..)) && @within(de.gmorling.methodvalidation.spring.AutoValidating)")
  public Object validateMethodInvocation(ProceedingJoinPoint pjp) throws Throwable {
    Object result;
    MethodSignature signature = (MethodSignature) pjp.getSignature();
    MethodValidator methodValidator = validator.unwrap( MethodValidator.class );


    Set<MethodConstraintViolation<Object>> parametersViolations = methodValidator.validateParameters(
        pjp.getTarget(), signature.getMethod(), pjp.getArgs()
    );
    if ( !parametersViolations.isEmpty() ) {
      throw new MethodConstraintViolationException( parametersViolations );
    }


    result =  pjp.proceed(); //Execute the method


    Set<MethodConstraintViolation<Object>> returnValueViolations = methodValidator.validateReturnValue(
        pjp.getTarget(), signature.getMethod(), result
    );
    if ( !returnValueViolations.isEmpty() ) {
      throw new MethodConstraintViolationException( returnValueViolations );
    }

View Full Code Here

Examples of org.hibernate.validator.MethodValidator

  private ValidatorFactory validatorFactory;


  @Override
  public Object invoke(MethodInvocation invocation) throws Throwable {


    MethodValidator validator = validatorFactory.getValidator().unwrap(
      MethodValidator.class);


    Set<MethodConstraintViolation<Object>> violations = validator
      .validateParameters(
        invocation.getThis(), invocation.getMethod(),
        invocation.getArguments());


    if (!violations.isEmpty()) {
      throw new MethodConstraintViolationException(violations);
    }


    Object result = invocation.proceed();


    violations = validator.validateReturnValue(
            invocation.getThis(),
            invocation.getMethod(),
            result);


    if (!violations.isEmpty()) {

View Full Code Here

Examples of org.hibernate.validator.MethodValidator

  private ValidatorFactory validatorFactory;


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


    MethodValidator validator = validatorFactory.getValidator().unwrap(
      MethodValidator.class);


    Set<MethodConstraintViolation<Object>> violations = validator
      .validateParameters(
        ctx.getTarget(), ctx.getMethod(), ctx.getParameters());


    if (!violations.isEmpty()) {
      throw new MethodConstraintViolationException(violations);
    }


    Object result = ctx.proceed();


    violations = validator.validateReturnValue(ctx.getTarget(), ctx.getMethod(), result);


    if (!violations.isEmpty()) {
      throw new MethodConstraintViolationException(violations);
    }

View Full Code Here

Examples of org.hibernate.validator.method.MethodValidator


            }
         }
      }
      Validator validator = validatorFactory.getValidator();
      MethodValidator methodValidator = validator.unwrap(MethodValidator.class);
      return  new GeneralValidatorImpl(validator, methodValidator);
   }

View Full Code Here

Examples of org.junit.internal.runners.MethodValidator

    @Test public void a() {
    }
  }
  
  @Test public void overloaded() {
    MethodValidator validator= new MethodValidator(Confused.class);
    List<Throwable> errors= validator.validateAllMethods();
    assertEquals(1, errors.size());
  }

View Full Code Here

0 1

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.