In the development of Java API, parameter verification is a very important link. Using the Bean Validation framework, you can easily verify parameters to ensure the legitimacy of API parameter transfers. This article will introduce how to use Bean Validation.
1. What is Bean Validation?
Bean Validation is part of the Java EE 6 specification. It is an annotation-based parameter validation framework that can be used to add validation rules to annotations such as methods, constructors, fields and properties. These annotations can help developers better prevent input errors during the code writing phase, and detect and prompt user input errors at runtime.
The Bean Validation framework mainly solves the following problems:
2. How does Bean Validation work?
The Bean Validation framework uses annotations to mark parameters that need to be verified. These annotations include @NotNull, @Min, @Max, @Size, @Pattern, etc. When parameters are passed to the method, the Bean Validation framework automatically executes the corresponding verification rules. When the verification fails, the Bean Validation framework sends an error message. Developers can write custom validation rules to meet business needs.
The Bean Validation framework provides a set of predefined validation rules that can be applied to properties and method parameters in Java Beans. Predefined rules include:
@NotNull: Check whether it is a null value
@Size: Check the length of String, Collection, Map and Array
@Min, @Max : Check the size of the value
@Email: Check whether it is an email address
@Pattern: Check the string according to the regular expression
When using the Bean Validation framework, you need to The classpath contains javax.validation-api and the corresponding Bean Validation implementation, such as Hibernate Validator. Through Maven, you can add the following dependencies:
<dependency> <groupId>javax.validation</groupId> <artifactId>validation-api</artifactId> <version>2.0.1.Final</version> </dependency> <dependency> <groupId>org.hibernate.validator</groupId> <artifactId>hibernate-validator</artifactId> <version>6.0.10.Final</version> </dependency>
3. Bean Validation example
Assume we have a User class, which contains the basic information of the user, now needs to verify the attributes in the User class:
public class User { private String name; private Integer age; private String email; private String address; // getters and setters }
The verification rules required by the project are as follows:
We can use Bean Validation to define these validation rules. The specific implementation is as follows:
public class UserValidator { private Validator validator; public UserValidator() { ValidatorFactory factory = Validation.buildDefaultValidatorFactory(); validator = factory.getValidator(); } /** * 对 User 对象进行校验 * * @param user * @return */ public String validate(User user) { Set<ConstraintViolation<User>> violations = validator.validate(user); StringBuilder result = new StringBuilder(); if (!violations.isEmpty()) { for (ConstraintViolation<User> violation : violations) { result.append(violation.getMessage()).append(";"); } } return result.toString(); } }
In the UserValidator class, we use the Validator tool class, created through the buildDefaultValidatorFactory() method A ValidatorFactory object, thereby creating an instantiated Validator object. User objects can be verified by calling the validator.validate(user) method. For the verification results, we record all error information in the StringBuilder object and return it to the calling end.
Finally, we can use the UserValidator object in the test class and perform the test:
public class UserValidatorTest { @Test void testValidateUser() { User user = new User(); user.setName("abcd"); user.setAge(300); user.setEmail("abc"); user.setAddress(null); UserValidator validator = new UserValidator(); String result = validator.validate(user); assertThat(result, containsString("Name length must be between 5 and 10.")); assertThat(result, containsString("Size must be between 1 and 200.")); assertThat(result, containsString("must be a well-formed email address")); } }
In the above test method, we created a User object whose attributes do not comply with the validation rules , so calling the validate() method of UserValidator will return the corresponding error message.
4. Summary
This article introduces the concept and usage of the Bean Validation framework. The framework verifies parameters through annotations, which can help developers prevent input errors when writing code and detect and prompt user input errors at runtime. At the same time, developers can write customized verification rules according to business needs to meet more complex verification scenarios.
The above is the detailed content of Using Bean Validation for parameter verification in Java API development. For more information, please follow other related articles on the PHP Chinese website!