Using Bean Validation for parameter verification in Java API development

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:

1. Verify business logic and restrictions (for example: whether it is empty, whether it is a mailbox, whether it is a number, etc.).
2. Verify format and syntax (for example: date, phone number, zip code, etc.).
3. Verify the interdependence of two or more fields (for example: start date must be earlier than end date).

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:

1. name No Is empty and the length is greater than 5 and less than 10;
2. age is not empty and greater than 0 and less than 200;
3. email is not empty and is a valid email address;
4. address can be empty.

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!