The technical principles of the Bean Validation Scala framework in the Java library analysis
The technical principles of the Bean Validation Scala framework in the Java library analysis
Bean Validation is a standardized framework for verifying the JavaBean object. It defines a series of annotations and verifications that to verify the attributes used to verify the objects that meet the expected constraints.Although Bean Validation is designed for the Java class library, it can also be used well with the Scala code.
It is very simple to use Bean Validation in Java. We only need to add corresponding annotations to the attributes that need to be verified, such as@notnull,@siZe,@min,@max, etc.Then call the verification device to verify at the place where the verification is required.The following is a simple Java example:
import javax.validation.constraints.*;
public class User {
@NotNull
@Size(min = 5, max = 10)
private String username;
@NotNull
@Email
private String email;
// getters and setters
}
In the above examples, we use @Notnull annotations to ensure that the username and email properties cannot be empty, and @Size and @email annotations are used to verify whether their length and format are correct.Next, we can use the verification device provided by Bean Validation to verify these comments:
import javax.validation.*;
import java.util.Set;
public class ValidatorDemo {
public static void main(String[] args) {
ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();
User user = new User();
user.setUsername("john");
user.setEmail("invalid_email");
Set<ConstraintViolation<User>> violations = validator.validate(user);
for (ConstraintViolation<User> violation : violations) {
System.out.println(violation.getMessage());
}
}
}
In the above examples, we first obtain a validatorFactory instance through the BUILDDEFAULTVALTVALTVALIDALIDALIDALIDIDATORDACTORY () method of the Validation class, and then obtain a Validator object through this instance.Next, we created a User object and set some values that do not meet the constraints for its attributes.Finally, we call the value () method of the value of value to verify and print out all the verification error information.
It is also very simple to use Bean Validation in SCALA. We can directly use Java's Bean Validation API for verification.However, because SCALA has more powerful grammar and characteristics, we can also use them to simplify our code.The following is an example that shows how to use Bean Validation in SCALA:
scala
import javax.validation.constraints._
import javax.validation.{Validation, Validator, ConstraintViolation}
class User {
@NotNull
@Size(min = 5, max = 10)
var username: String = _
@NotNull
@Email
var email: String = _
}
object ValidatorDemo {
def main(args: Array[String]): Unit = {
val factory = Validation.buildDefaultValidatorFactory
val validator = factory.getValidator
val user = new User
user.username = "john"
user.email = "invalid_email"
val violations = validator.validate(user)
violations.forEach(violation => println(violation.getMessage))
}
}
In the above example, we define a User class and use the same annotations as the Java example.However, in the SCALA code, we use VAR keyword definition attributes and use the default value of _ initialization attributes.In terms of the use of the verification device, SCALA and Java examples are almost the same, with only some grammar differences.
In summary, the technical principles of the Bean Validation Scala framework in the Java library are the same as the Java example. The attributes of the object are used to verify the attributes of the object to meet the constraints.Although the Bean Validation API of Java can be used directly for verification, the syntax and characteristics of SCALA can better simplify the code and improve the development efficiency.
