I am looking for annotation to annotate pojo class which I need to validate during request deserialization. I am searching for annotation to pass as parameter class which will validate my pojo.
Implementation can look like that:
#ValidateAnnotation(class = ExampleClassValidator.class)
public class ExampleClass {
private String name;
}
Has anyone know any of spring annotation for that approach or some dependency which offer that declarative validation ? I am asking because I cannot find any similar solution in documentation.
You can use #InitBinder to configure a validator based on the target of the method. Here's a simple example:
Annotation class:
package test.xyz;
import org.springframework.validation.Validator;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
#Retention(RetentionPolicy.RUNTIME)
public #interface ValidateAnnotation {
Class<? extends Validator> value();
}
The example class to be validated:
package test.xyz;
#ValidateAnnotation(ExampleClassValidator.class)
public class ExampleClass {
}
The validator class:
package test.xyz;
import org.springframework.validation.Errors;
public class ExampleClassValidator implements org.springframework.validation.Validator {
#Override
public boolean supports(Class<?> aClass) {
return ExampleClass.class.isAssignableFrom(aClass);
}
#Override
public void validate(Object o, Errors errors) {
}
}
And finally the controller class with the #InitBinder definition:
import org.springframework.stereotype.Controller;
import org.springframework.validation.Errors;
import org.springframework.validation.Validator;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import test.xyz.ExampleClass;
import test.xyz.ValidateAnnotation;
import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.util.Collections;
#Controller
public class ExampleController {
#RequestMapping(value="test-endpoint", method= RequestMethod.GET)
public #ResponseBody
Object testMethod(#Valid ExampleClass exampleClass, Errors errors) {
return Collections.singletonMap("success", true);
}
#InitBinder
public void initBinder(WebDataBinder binder, HttpServletRequest request) throws IllegalAccessException, InstantiationException {
Class<?> targetClass = binder.getTarget().getClass();
if(targetClass.isAnnotationPresent(ValidateAnnotation.class)) {
ValidateAnnotation annotation = targetClass.getAnnotation(ValidateAnnotation.class);
Class<? extends Validator> value = annotation.value();
Validator validator = value.newInstance();
binder.setValidator(validator);
}
}
}
Explanation:
You can use the WebDataBinder's getTarget method to access the target to be validated. From there it is straightforward to check the annotation on the class, get the validator class, and set it on the binder. I believe you can also use the #ControllerAdvice annotation to configure a global InitBinder. As a disclaimer, I don't know if it is recommended to access the binder target within the InitBinder, but I haven't had any issues the few times I've done so.
For normal validation you can annotate your class with the annotations from the javax.validation.constraints package, like javax.validation.constraints.NotEmpty. For custom validation, you can make your own annotation that will call a custom validator that you write.
For example, if you wanted to create a validator that makes sure a field is nine characters long you could do the following:
First, create your custom validation annotation.
#Documented
#Constraint(validatedBy = NineCharactersValidator.class)
#Target( { ElementType.METHOD, ElementType.FIELD })
#Retention(RetentionPolicy.RUNTIME)
public #interface NineCharactersOnly {
String message() default "This field must contain exactly nine characters";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
Next, create your custom validator:
public class NineCharactersValidator implements ConstraintValidator<NineCharactersOnly, String> {
#Override
public void initialize(NineCharactersOnly contactNumber) {
}
#Override
public boolean isValid(String contactField, ConstraintValidatorContext cxt) {
return contactField != null && contactField.length() == 9;
}
}
Next, use the annotation on fields that need to be constrained on your pojo.
public class ExampleClass {
#NineCharactersOnly
private String fieldThatMustBeNineCharacters;
}
Next, mark your method parameters in the controller with #Valid so they will be validated by Spring:
#RestController
public class CustomValidationController {
#PostMapping("/customValidationPost")
public ResponseEntity<String> customValidation(#Valid ExampleClass exampleClass, BindingResult result, Model m) {
// we know the data is valid if we get this far because Spring automatically validates the input and
// throws a MethodArgumentNotValidException if it's invalid and returns an HTTP response of 400 (Bad Request).
return ResponseEntity.ok("Data is valid");
}
}
Finally, if you want custom logic for handling validation errors instead of just sending a 400, you can create a custom validation handler method.
#ResponseStatus(HttpStatus.BAD_REQUEST)
#ExceptionHandler(MethodArgumentNotValidException.class)
public Map<String, String> handleValidationException(MethodArgumentNotValidException e) {
Map<String, String> errors = new HashMap<>();
d.getBindingResult().getAllErrors().forEach((error) -> {
String fieldName = ((FieldError) error).getField();
String errorMessage = error.getDefaultMessage();
errors.put(fieldName, errorMessage);
});
return errors;
}
Maybe writing your custom annotation and using Spring AOP will help you. Spring AOP is quite simple.
I found pretty good solution but in one place i used reflection :(
Please feel free to comment and rate this solution, is it good enough or something could be done better.
I had create own annotation
#Retention(RetentionPolicy.RUNTIME)
#Target(ElementType.TYPE)
public #interface Validator {
Class<? extends org.springframework.validation.Validator> validator();
}
I next step I extend LocalValidatorFactoryBean to override validate method and here I was forced to use reflection to get class from annotation.
#Component
#RequiredArgsConstructor
class CustomLocalValidatorFactoryBean extends LocalValidatorFactoryBean {
private final Map<Class<? extends Validator>, Validator> validators;
#Override
public void validate(Object target, Errors errors, Object... validationHints) {
Class<? extends Validator> validatorKey = target.getClass().getAnnotation(com.validation.validator.Validator.class).validator();
Optional.ofNullable(validators.get(validatorKey)).ifPresentOrElse(
validator ->
validator.validate(target, errors),
() -> super.validate(target, errors, validationHints)
);
}
}
I annotate pojo with my annotation to specify validator.
#Data
#Validator(validator = PersonValidator.class)
public class PersonDto {
private final String name;
private final String surname;
private final Integer age;
}
As you can see in my CustomLocalValidatorFactoryBean I injected a map of validators, in this map i store validators assigned to key which is the class of this validator. This class i specify in annotation in pojo to fetch suitable validator for currect validate target. And this is my configuration of validatos map.
#Configuration
class ValidatorConfig {
#Bean
Map<Class<? extends Validator>, Validator> validators() {
var validators = new HashMap<Class<? extends Validator>, Validator>();
validators.put(PersonValidator.class, new PersonValidator());
return validators;
}
}
I specify custom #RestControllerAdvice and override method handleMethodArgumentNotValid.
#RestControllerAdvice
class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
#Override
protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers,
HttpStatus status, WebRequest request) {
Map<String, String> errors = new HashMap<>();
ex.getBindingResult().getAllErrors().forEach((error) -> {
String fieldName = error.getCode();
String errorMessage = error.getDefaultMessage();
errors.put(fieldName, errorMessage);
});
return new ResponseEntity<>(errors, HttpStatus.BAD_REQUEST);
}
}
And this is my validator, it could be bean with dao acces but it could also be simple pojo.
public class PersonValidator implements Validator {
#Override
public boolean supports(Class<?> aClass) {
return PersonDto.class.isAssignableFrom(aClass);
}
#Override
public void validate(Object object, Errors errors) {
Optional.of(object).map(obj -> (PersonDto) obj).ifPresent(person -> {
Optional.ofNullable(person.getName())
.filter(name -> Strings.isNotBlank(name) && name.length() >= 3)
.ifPresentOrElse(name -> doNothing(), () -> errors.reject("person.name", "name of person is invalid!"));
});
}
}
What do you think about that configuration, is it cannon on sparrow or you just like that solution ?
Annotation
#Target({ElementType.METHOD})
#Retention(RetentionPolicy.RUNTIME)
public #interface MyAnnotation {
String value();
}
AOP
#Aspect
#Component
public class MyAspect {
#Around("#annotation(MyAnnotation)")
public Object aroundHandler(ProceedingJoinPoint joinPoint) throws Throwable {
...
}
Controller
#Controller
public class MyController {
#RequestMapping(value="/hello", method=RequestMethod.GET)
#ResponseBody
#MyAnnotation(value="hello")
public String hello() {
return "hello";
}
}
in above condition, my aop does not work...
It works fine with other methods, which is not annotated by #Controller.
And it works fine with aop expression and controller method.
Is it possible to use aop by annotation with controller method?
Try this:
#Around("#annotation(myAnnotation)")
public Object aroundHandler(ProceedingJoinPoint joinPoint,MyAnnotation myAnnotation) throws Throwable {
// Do Something
}
I think you need to use #within...this blog post may help https://www.productiveprogrammer.net/?p=49
i have spring MVC controller
#Controller
#RequestMapping({ "/user/limits" })
public class UserController {
#Value("${wsgServiceURL}")
private String wsgServiceURL;
.
.
which populate wsgServiceURL value from property file
is that possible to run validation code on that value before population
Yes it is possible using type safe configuration properties through the #ConfigurationPropertiesmechanism
#Controller
#RequestMapping({ "/user/limits" })
#ConfigurationProperties("uc")
public class UserController {
// will map to uc.wsgServiceURL in property file
private String wsgServiceURL;
You can also add validation with #Validated and use use JSR-303 javax.validation
you can do something like the below,
#Controller
#RequestMapping({ "/user/limits" })
public class UserController {
private String wsgServiceURL;
#Autowired
public void initProperty(#Value("${wsgServiceURL}") String wsgServiceURL) {
if(wsgServiceURL== null) {
// Error handling here
}
}
}
I have the following unit test:
#RunWith(SpringJUnit4ClassRunner.class)
#SpringApplicationConfiguration(classes = {EqualblogApplication.class})
#WebAppConfiguration
#TestPropertySource("classpath:application-test.properties")
public class PostServiceTest {
// ...
#Test(expected = ConstraintViolationException.class)
public void testInvalidTitle() {
postService.save(new Post()); // no title
}
}
The code for save in PostService is:
public Post save(#Valid Post post) {
return postRepository.save(post);
}
The Post class is marked with #NotNull in most fields.
The problem is: no validation exception is thrown.
However, this happens only in testing. Using the application normally runs the validation and throws the exception.
Note: I would like to do it automatically (on save) and not by manually validating and then saving (since it's more realistic).
This solution works with Spring 5. It should work with Spring 4 as well. (I've tested it on Spring 5 and SpringBoot 2.0.0).
There are three things that have to be there:
in the test class, provide a bean for method validation (PostServiceTest in your example)
Like this:
#TestConfiguration
static class TestContextConfiguration {
#Bean
public MethodValidationPostProcessor bean() {
return new MethodValidationPostProcessor();
}
}
in the class that has #Valid annotations on method, you also need to annotate it with #Validated (org.springframework.validation.annotation.Validated) on the class level!
Like this:
#Validated
class PostService {
public Post save(#Valid Post post) {
return postRepository.save(post);
}
}
You have to have a Bean Validation 1.1 provider (such as Hibernate Validator 5.x) in the classpath. The actual provider will be autodetected by Spring and automatically adapted.
More details in MethodValidationPostProcessor documentation
Hope that helps
This is how I did it by loading ValidationAutoConfiguration.class into context:
#SpringBootTest
#ContextConfiguration(classes = { MyComponent.class, ValidationAutoConfiguration.class
public class MyComponentValidationTest {
#Autowired
private MyComponent myComponent;
#Test
void myValidationTest() {
String input = ...;
// static import from org.assertj.core.api.Assertions
assertThatThrownBy(() -> myComponent.myValidatedMethod(input))
.isInstanceOf(ConstraintViolationException.class)
.hasMessageContaining("my error message");
}
}
And MyComponent class:
#Component
#Validated
public class MyComponent {
public void myValidatedMethod(#Size(min = 1, max = 30) String input) {
// method body
}
)
I am using Spring 3.1.
I am trying to use Bean-Validator to validate a method.
My class:
#Named
#Scope("prototype")
#Validated
public class MyClass implements someClass
{
..
#Override
public void handle(#NotNull MyObj myObj) {
..
}
}
Now this is the calling class:
#Named
public class CallingClass{
..
#Inject
Provider<MyClass> myClass;
public void doSomething(Myobj myObj)
{
MyClass handler = myClass.get(); //here I get the exception
myClass.handle(myObj);
}
That's the exception:
Caused by: java.lang.ClassCastException: com.sun.proxy.$Proxy85 cannot be cast to com...MyClass
Any idea?
thanks,
ray.
try to put #Validated and constraints on parameters to your interface if the object is not pojo.