Verwendung der Bean-Validierung zur Parameterüberprüfung in der Java-API-Entwicklung

Bei der Entwicklung der Java-API ist die Parameterüberprüfung ein sehr wichtiger Link. Mithilfe des Bean-Validierungs-Frameworks können Sie Parameter einfach überprüfen, um die Legitimität von API-Parameterübertragungen sicherzustellen. In diesem Artikel wird die Verwendung der Bean-Validierung vorgestellt.

1. Was ist Bean-Validierung?

Bean-Validierung ist Teil der Java EE 6-Spezifikation. Es handelt sich um ein annotationsbasiertes Parametervalidierungs-Framework, mit dem Validierungsregeln zu Annotationen wie Methoden, Konstruktoren, Feldern und Eigenschaften hinzugefügt werden können. Diese Anmerkungen können Entwicklern helfen, Eingabefehler während der Code-Schreibphase besser zu verhindern und Benutzereingabefehler zur Laufzeit zu erkennen und zu melden.

Das Bean-Validierungs-Framework löst hauptsächlich die folgenden Probleme:

1. Überprüfen Sie die Geschäftslogik und Einschränkungen (z. B. ob es leer ist, ob es sich um ein Postfach handelt, ob es sich um eine Nummer handelt usw.).
2. Überprüfen Sie Format und Syntax (z. B. Datum, Telefonnummer, Postleitzahl usw.).
3. Überprüfen Sie die gegenseitige Abhängigkeit von zwei oder mehr Feldern (z. B.: Das Startdatum muss vor dem Enddatum liegen).

2. Wie funktioniert die Bean-Validierung?

Das Bean-Validierungs-Framework verwendet Annotationen, um Parameter zu markieren, die überprüft werden müssen. Zu diesen Annotationen gehören @NotNull, @Min, @Max, @Size, @Pattern usw. Wenn Parameter an die Methode übergeben werden, führt das Bean-Validierungs-Framework automatisch die entsprechenden Überprüfungsregeln aus. Wenn die Überprüfung fehlschlägt, sendet das Bean-Validierungs-Framework eine Fehlermeldung. Entwickler können benutzerdefinierte Validierungsregeln schreiben, um den Geschäftsanforderungen gerecht zu werden.

Das Bean Validation Framework bietet eine Reihe vordefinierter Validierungsregeln, die auf Eigenschaften und Methodenparameter in Java Beans angewendet werden können. Zu den vordefinierten Regeln gehören:

@NotNull: Überprüfen Sie, ob es sich um einen Nullwert handelt.

@Size: Überprüfen Sie die Länge von String, Collection, Map und Array.

@Min, @Max: Überprüfen Sie die Größe des Werts.

@Email : Überprüfen Sie, ob für E-Mail-Adressen

@Pattern: Überprüfen Sie Zeichenfolgen basierend auf regulären Ausdrücken

Bei Verwendung des Bean-Validation-Frameworks müssen Sie javax.validation-api und die entsprechende Bean-Validation-Implementierung in den Klassenpfad einschließen, z. B. Hibernate Validator. Über Maven können Sie die folgenden Abhängigkeiten hinzufügen:

<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-Validierungsbeispiel

Angenommen, wir haben eine Benutzerklasse, die die grundlegenden Informationen des Benutzers enthält. Jetzt müssen wir die Attribute in der Benutzerklasse überprüfen:

public class User {
    private String name;
    private Integer age;
    private String email;
    private String address;
  
    // getters and setters
}

Überprüfung durch das Projekt erforderlich. Die Regeln lauten wie folgt:

1. Name ist nicht leer und die Länge ist größer als 5 und kleiner als 10;
2. E-Mail ist nicht leer nicht leer und ist eine gültige E-Mail-Adresse;
3. Adresse kann leer sein.
Wir können Bean Validation verwenden, um diese Validierungsregeln zu definieren. Die spezifische Implementierung ist wie folgt:

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 der UserValidator-Klasse verwenden wir die Validator-Toolklasse, um ein ValidatorFactory-Objekt über die buildDefaultValidatorFactory()-Methode zu erstellen Validator-Objekt. Benutzerobjekte können durch Aufrufen der Methode validator.validate(user) überprüft werden. Für die Verifizierungsergebnisse zeichnen wir alle Fehlerinformationen im StringBuilder-Objekt auf und geben sie an das aufrufende Ende zurück.

Schließlich können wir das UserValidator-Objekt in der Testklasse verwenden und den Test durchführen:

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 der obigen Testmethode haben wir ein Benutzerobjekt erstellt, dessen Attribute nicht den Validierungsregeln entsprachen, also der „validate()“ von UserValidator wurde aufgerufen Die Methode gibt die entsprechende Fehlermeldung zurück.

4. Zusammenfassung

Dieser Artikel stellt das Konzept und die Verwendung des Bean-Validierungs-Frameworks vor. Das Framework überprüft Parameter durch Anmerkungen, was Entwicklern dabei helfen kann, Eingabefehler beim Schreiben von Code zu verhindern und Benutzereingabefehler zur Laufzeit zu erkennen und zu melden. Gleichzeitig können Entwickler benutzerdefinierte Verifizierungsregeln entsprechend den Geschäftsanforderungen schreiben, um komplexere Verifizierungsszenarien zu erfüllen.

Das obige ist der detaillierte Inhalt vonVerwendung der Bean-Validierung zur Parameterüberprüfung in der Java-API-Entwicklung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!