Detailed explanation of the use of validation background parameter verification in Java

This article mainly introduces the detailed use of java validation background parameter verification. The editor thinks it is quite good. Now I will share it with you and give you a reference. Let’s follow the editor and take a look.

1. Foreword

In the background development process, the verification of parameters becomes an indispensable part of the development environment. The missing link. For example, parameters cannot be null, and email must conform to the format of email. If you manually perform if judgments or write regular expressions to judge, the development efficiency will be too slow, and you will inevitably fall behind in the game of time, cost, and quality. Therefore, abstracting the verification layer is an inevitable result. Here are several solutions.

2. Several solutions

1. The valid of struts2 can be configured in xml. The rules and returned information are described in xml. This This method is more troublesome and has low development efficiency, so it is not recommended

2. The validation bean is developed based on the JSR-303 standard and is implemented using annotations, which is very convenient, but it is just an interface and has no specific implementation. Hibernate Validator is a hibernate independent package that can be quoted directly. It implements the validation bean and also extends it. It is relatively powerful. The implementation diagram is as follows:

Click here to view the Chinese version Official manual

3. oval is an extensible Java object data verification framework. Verification rules can be set through configuration files, Annotation, and POJOs. You can use pure Java language, JavaScript, Groovy, BeanShell, etc. to write rules. I will not explain too much this time

3. Introduction to bean validation framework verification

bean validation package is maintained on maven. The coordinates of the latest package are as follows:

<dependency>

  <groupId>javax.validation</groupId>

  <artifactId>validation-api</artifactId>

  <version>1.1.0.Final</version>

</dependency>

Click here to view the latest coordinate address

Open after downloading This package has a package called constraints, which contains verification annotations:

　

Let’s start practicing with code:

1. Define a Bean to be verified: Student.java

##

package com.shishang;

import javax.validation.constraints.*;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;

public class Student implements Serializable {


  @NotNull(message = "名字不能为空")
  private String name;

  @Size(min = 6,max = 30,message = "地址应该在6-30字符之间")
  private String address;

  @DecimalMax(value = "100.00",message = "体重有些超标哦")
  @DecimalMin(value = "60.00",message = "多吃点饭吧")
  private BigDecimal weight;

  private String friendName;
  @AssertTrue
  private Boolean isHaveFriend(){
    return friendName != null?true:false;
  }

  @Future(message = "生日必须在当前实践之前")
  private Date birthday;

  @Pattern(regexp = "^(.+)@(.+)$",message = "邮箱的格式不合法")
  private String email;


  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getAddress() {
    return address;
  }

  public void setAddress(String address) {
    this.address = address;
  }

  public BigDecimal getWeight() {
    return weight;
  }

  public void setWeight(BigDecimal weight) {
    this.weight = weight;
  }

  public String getFriendName() {
    return friendName;
  }

  public void setFriendName(String friendName) {
    this.friendName = friendName;
  }

  public Date getBirthday() {
    return birthday;
  }

  public void setBirthday(Date birthday) {
    this.birthday = birthday;
  }

  public String getEmail() {
    return email;
  }

  public void setEmail(String email) {
    this.email = email;
  }
}

2. Test class: StudentTest.java

package com.use;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;

public class StudentTest implements Serializable {
  public static void main(String[] args) {
    Student xiaoming = getBean();
    List<String> validate = validate(xiaoming);
    validate.forEach(row -> {
      System.out.println(row.toString());
    });

  }

  private static Student getBean() {
    Student bean = new Student();
    bean.setName(null);
    bean.setAddress("北京");
    bean.setBirthday(new Date());
    bean.setFriendName(null);
    bean.setWeight(new BigDecimal(30));
    bean.setEmail("xiaogangfan163.com");
    return bean;
  }

  private static ValidatorFactory factory = Validation.buildDefaultValidatorFactory();

  public static <T> List<String> validate(T t) {
    Validator validator = factory.getValidator();
    Set<ConstraintViolation<T>> constraintViolations = validator.validate(t);

    List<String> messageList = new ArrayList<>();
    for (ConstraintViolation<T> constraintViolation : constraintViolations) {
      messageList.add(constraintViolation.getMessage());
    }
    return messageList;
  }
}

3. Run the testValidation() method, and the output is as follows:

1. The address should be between 6-30 characters

2. The format of the email address is incorrect Legal

3. Birthday must be before the current time

4. Eat more food

5. Name cannot Is empty

4. Summary

1. Like @NotNull, @Size, etc. are relatively simple and easy to understand, so I won’t say much

2. Because bean validation only provides an interface but does not implement it, you need to add a provider package when using it, such as hibernate-validator

3. @Pattern because This is a regular expression, so it can do a lot of things, such as Chinese or numbers, email addresses, lengths, etc.

4. @AssertTRue This is essentially different from other verification annotations. , this annotation applies to multiple fields. In the example, the isHaveFriend method relies on friendName field verification

5. The verification API has been processed by me, so that the verification information can be returned in batches

6. Sometimes the annotations we need may not be provided. In this case, we need to customize annotations and write implementation classes. Let’s talk about the use of custom annotations

##4. Custom bean validation annotation validationSometimes the built-in framework cannot meet our needs. At this time, we need to do it ourselves. Well, this is not difficult. Let’s talk about it below.

This example verifies whether the string is uppercase or lowercase constraint annotation. The code is as follows:

1. Enumeration type CaseMode, to represent the uppercase or lowercase mode

 package com.defineconstrain;

/**
 * created by xiaogangfan
 * on 16/10/25.
 */
public enum CaseMode {
  UPPER,
  LOWER;
}

2. Define a CheckCase constraint annotation

package com.defineconstrain;

/**
 * created by xiaogangfan
 * on 16/10/25.
 */
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;

@Target( { METHOD, FIELD, ANNOTATION_TYPE })
@Retention(RUNTIME)
@Constraint(validatedBy = CheckCaseValidator.class)
@Documented
public @interface CheckCase {

  String message() default "{com.mycompany.constraints.checkcase}";

  Class<?>[] groups() default {};

  Class<? extends Payload>[] payload() default {};

  CaseMode value();

}

3. Constraint CheckCase validator

package com.defineconstrain;

/**
 * created by xiaogangfan
 * on 16/10/25.
 */
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class CheckCaseValidator implements ConstraintValidator<CheckCase, String> {

  private CaseMode caseMode;

  public void initialize(CheckCase constraintAnnotation) {
    this.caseMode = constraintAnnotation.value();
  }

  public boolean isValid(String object, ConstraintValidatorContext constraintContext) {

    if (object == null)
      return true;

    if (caseMode == CaseMode.UPPER)
      return object.equals(object.toUpperCase());
    else
      return object.equals(object.toLowerCase());
  }

}

4. Add a property to Student.java

@CheckCase(value = CaseMode.LOWER,message = "名字的拼音需要小写")
private String spellName;

5. Add a line to the getBean() method of StudentTest.java

bean.setSpellName("XIAOGANGFAN");

6. Run the testValidation() method, the output is as follows:

The address should be between 6-30 characters
The email format is invalid
The birthday must be before the current time
Eat more food Bar
The pinyin of the name needs to be lowercase
The name cannot be empty

The above is the detailed content of Detailed explanation of the use of validation background parameter verification in Java. For more information, please follow other related articles on the PHP Chinese website!