JavaBeans-Validierung durchführen

JavaBeans Validation (Bean Validation) ist ein Validierungsmodell, das seit der Einführung der Plattform Java Enterprise Edition 6 verfügbar ist. Es bietet eine standardisierte Möglichkeit, Eingabedaten in verschiedenen Java-Anwendungen zu validieren. In einem früheren Beitrag haben wir erläutert, wie Java-DTOs in modernen Anwendungen dazu beitragen, versehentliche Datenlecks zu verhindern.

In diesem Artikel erstellen wir eine neue Java-Anwendung und validieren einige Beispielzeichenfolgen, um zu zeigen, wie JavaBean Validation funktioniert. Doch zuerst sehen wir uns an, was Beans sind. 

JavaBeans sind Java-Objekte mit Eigenschaften und Methoden, die Daten speichern und zwischen verschiedenen Teilen einer Java-Anwendung übertragen. Beans sind wiederverwendbare Komponenten, die Daten und Verhalten einer Java-Anwendung kapseln. Sie sind eine standardisierte Art, Objekte darzustellen, und folgen bestimmten Entwurfsmustern und Konventionen. 

• JavaBeans enthalten Eigenschaften, also Instanzvariablen, die den Zustand eines Objekts darstellen. Diese Variablen sollten privat sein. Über Getter- und Setter-Methoden greifen sie auf die in einem Bean gespeicherten Daten zu.

• Konstruktoren ohne Argumente dienen dazu, eine Instanz eines Beans zu erstellen. Wir können weitere Konstruktoren hinzufügen, um unterschiedliche Möglichkeiten zur Initialisierung eines Beans bereitzustellen.

• JavaBeans sind serialisierbar. Das bedeutet, ihr Zustand lässt sich in einer Datei speichern oder über ein Netzwerk übertragen.

• JavaBeans folgen Namenskonventionen. Dazu gehört, die Methoden getXXX und setXXX zu verwenden, um auf Eigenschaften zuzugreifen und deren Werte festzulegen.

• JavaBeans enthalten häufig BeanInfo-Klassen, die Tools und IDEs Informationen über das Bean bereitstellen.

Wir verwenden JavaBeans häufig als Bausteine, um Daten in größeren Anwendungen zu organisieren und zu strukturieren. Sie enthalten in der Regel Instanzvariablen (Eigenschaften) sowie Getter- und Setter-Methoden (getXXX und setXXX), um auf die im Bean gespeicherten Daten zuzugreifen. Außerdem erstellen wir mit JavaBeans benutzerdefinierte Objekte, die sich in verschiedenen Teilen einer Anwendung wiederverwenden lassen. So lässt sich der Code einfacher warten und aktualisieren.

JavaBeans Validation verwenden

Beans werden vor allem dazu verwendet, Benutzereingaben zu validieren. Dazu legen wir Einschränkungen für die Eigenschaften eines Beans fest, etwa Mindest- und Höchstlängen, zulässige Zeichen und Pflichtfelder. Anhand dieser Einschränkungen validieren wir anschließend die von Benutzern eingegebenen Daten, um sicherzustellen, dass sie die festgelegten Anforderungen erfüllen, bevor die Anwendung sie verarbeitet.

Das folgende Beispiel verwendet den Hibernate Validator in einem Apache-Maven-Projekt. Hibernate Validator ist die Referenzimplementierung für Bean Validation.

Eine Java-Anwendung erstellen

Zuerst müssen wir in der Maven-Datei pom.xml eine Abhängigkeit für Hibernate Validator anlegen. Verwenden Sie dazu den folgenden Code:

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.1.5.Final</version>
</dependency>

Anschließend fügen wir die Bean-Validation-API mithilfe des folgenden Codes als Abhängigkeit in pom.xml hinzu:

<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.1.Final</version>
</dependency>

Nun erstellen wir in einer neuen Datei namens BeanValidation.java ein Java-Projekt und importieren die benötigten Bibliotheken:

import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.validation.constraints.Pattern;
import java.util.Set;
import javax.validation.ConstraintViolation;

Als Nächstes erstellen wir mithilfe des folgenden Codes ein einfaches Bean mit einer zu validierenden Eigenschaft:

public class ExampleBean {
    @NotNull
    @Size(min=2, max=10)
    private String exampleString;

//Getters
    public String getExampleString() {
        return exampleString;
    }

//Setters
    public void setExampleString(String exampleString) {
        this.exampleString = exampleString;
    }
}

In diesem Beispiel legen die Annotationen @NotNull und @Size fest, dass die Eigenschaft exampleString nicht null sein darf und eine Mindestlänge von zwei sowie eine Höchstlänge von zehn Zeichen haben muss. Die Methoden getExampleString und setExampleStrin dienen in der Klasse ExampleBean als Getter und Setter für die Eigenschaft exampleString.

Bean Validation in der Praxis

Um die Klasse BeanValidation zum Validieren des Beans zu verwenden, führen wir Folgendes aus:

public class BeanValidation {
    public static void main(String[] args) {
        ExampleBean bean = new ExampleBean();
        bean.setExampleString("hello");
// Create a Validator instance using the default validation factory      
  ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();
// Validate an instance of the ExampleBean class and get a set of constraint violations, if any        
Set<ConstraintViolation<ExampleBean>> violations = validator.validate(bean);
        if (!violations.isEmpty()) {
            System.out.println("Errors:");
            for (ConstraintViolation<ExampleBean> violation : violations) {
                System.out.println(violation.getMessage());
            }
        } else {
            System.out.println("Validation successful");
        }
    }
}

Da wir den Zeichenfolgenwert auf hello gesetzt haben, besteht er die Validierung. Wenn wir der Eigenschaft exampleString einen Wert zuweisen, der die für ein Bean festgelegten Einschränkungen nicht erfüllt, gibt die Methode „validate“ eine Menge von ConstraintViolation-Objekten zurück, die die Fehler beschreiben.

Um Fehler bei nicht bestandener Zeichenfolgenvalidierung zu behandeln, erstellen wir Fehlerbehandlungsfälle, die Verstöße erkennen und bei Bedarf eine Fehlermeldung anzeigen.

Hier ist der vollständige Code für die Datei BeanValidation.java:

import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.validation.ConstraintViolation;

public class ExampleBean {
    @NotNull
    @Size(min=2, max=10)
    private String exampleString;

    public String getExampleString() {
        return exampleString;
    }

    public void setExampleString(String exampleString) {
        this.exampleString = exampleString;
    }
}

public class BeanValidation {
    public static void main(String[] args) {
        ExampleBean bean = new ExampleBean();
        bean.setExampleString("hello");

        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();

        Set<ConstraintViolation<ExampleBean>> violations = validator.validate(bean);

        if (!violations.isEmpty()) {
            System.out.println("Errors:");
            for (ConstraintViolation<ExampleBean> violation : violations) {
                System.out.println(violation.getMessage());
            }
        } else {
            System.out.println("Validation successful");
        }
    }
}

Dieses Beispiel gibt einen Fehler zurück, wenn die Eingabezeichenfolge kürzer als zwei Zeichen, länger als zehn Zeichen oder null ist. Erfüllt die Zeichenfolge diese Einschränkungen nicht, wird eine Fehlermeldung mit der nicht erfüllten Anforderung ausgegeben.

Hier ist ein Beispiel für Einschränkungen zur Validierung von Anmeldedaten mit E-Mail- und Passwortfeldern:

public class UserBean {
    @NotNull
    @Size(min=5, max=30)
    @Pattern(regexp = "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}")
    private String email;

    @NotNull
    @Size(min=8, max=15)
    @Pattern(regexp = "((?=.*[a-z])(?=.*\\d)(?=.*[A-Z])(?=.*[@#$%!]).{8,15})")
    private String password;

}

Die Klasse UserBean enthält zwei Eigenschaften: email und password. Für die Eigenschaft email wird sichergestellt, dass Eingaben mindestens fünf und höchstens dreißig Zeichen lang sind und dem Muster einer gültigen E-Mail-Adresse entsprechen. 

Für die Eigenschaft password wird sichergestellt, dass das Passwort nicht null ist, mindestens acht und höchstens fünfzehn Zeichen umfasst und mindestens einen Kleinbuchstaben, einen Großbuchstaben, eine Ziffer und ein Sonderzeichen enthält. 

Einschränkungen verstehen

Einschränkungen werden mithilfe von Annotationen definiert – speziellen Metadaten, die Java-Klassen, -Feldern und -Methoden hinzugefügt werden. Wir können Einschränkungen an verschiedenen Stellen auf die Eigenschaften einer Bean-Klasse anwenden, etwa direkt auf die Eigenschaft, auf eine Getter-Methode der Eigenschaft oder auf einen Konstruktorparameter der Klasse.

Nachdem die Einschränkungen für ein Bean definiert wurden, erfolgt die Validierung mithilfe eines Validator-Objekts aus der Bean-Validation-API. Das Validator-Objekt prüft, ob eine Bean-Instanz die Einschränkungen ihrer Eigenschaften erfüllt. Verstößt ein Bean gegen eine oder mehrere Einschränkungen, gibt der Validator eine Menge von Constraint-Verstößen zurück. Sie zeigt an, welche Eigenschaften die Validierung nicht bestanden haben und warum.

Die Bean-Validation-API stellt standardmäßig einige integrierte Einschränkungen für JavaBeans bereit, die wir sofort verwenden können. Dazu gehören @NotNull, @Size, @Pattern, @Min, @Max, @DecimalMin und@DecimalMax. Eine vollständige Liste der integrierten Einschränkungen finden Sie in der Dokumentation zu Hibernate Validator.

Benutzerdefinierte Einschränkungen definieren wir, um bestimmte Validierungsanforderungen zu erfüllen. Dazu erstellen wir eine benutzerdefinierte Annotation und implementieren einen ConstraintValidator, der die Validierungslogik festlegt. 

Benutzerdefinierte Annotationen erstellen

Um eine benutzerdefinierte Einschränkung für Bean Validation zu erstellen, müssen wir:

• Eine benutzerdefinierte Annotationsklasse erstellen und mit @Constraint annotieren. Damit wird angegeben, dass es sich bei der annotierten Klasse um eine benutzerdefinierte Einschränkung handelt.

• Die Validierungslogik in einer Klasse implementieren, die das Interface ConstraintValidator implementiert. Die Klasse muss Parameter für die benutzerdefinierte Einschränkungsannotation und den Typ der Elemente enthalten, die sie validieren kann.

• Die benutzerdefinierte Einschränkung registrieren, indem Sie der XML-Konfigurationsdatei für die Validierung einen Eintrag hinzufügen oder die benutzerdefinierte Einschränkungsklasse mit @Constraint(validatedBy=<Validator class>) annotieren.

Hier ist ein Beispiel für eine benutzerdefinierte Einschränkung namens ValidSearchTerm:

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

@Documented
@Constraint(validatedBy = ValidSearchTermValidator.class)
@Target({ FIELD })
@Retention(RUNTIME)
public @interface ValidSearchTerm {

    String message() default "Search term contains invalid characters";

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

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

Anschließend können wir die Validierungslogik implementieren, die mithilfe regulärer Ausdrücke die Einschränkung festlegt. In diesem Fall soll die Sucheingabe aus gewöhnlichen alphanumerischen Zeichen bestehen und keine Sonderzeichen enthalten:

public class ValidSearchTermValidator implements ConstraintValidator<ValidSearchTerm, String> {

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if (value == null) {
            return true;
        }
        return value.matches("[A-Za-z0-9]+");
    }
}

Anschließend verwenden wir die benutzerdefinierte Einschränkung in einem Bean wie folgt:

public class SearchBean {
    @ValidSearchTerm
    private String searchTerm;

    public String getSearchTerm() {
        return searchTerm;
    }

    public void setSearchTerm(String searchTerm) {
        this.searchTerm = searchTerm;
    }
}

Fazit zu Bean Validation

Bean Validation bietet eine einheitliche und konsistente Möglichkeit, Daten in Java-Anwendungen zu validieren. So können wir leichter Code schreiben und warten, der eine sichere Datenverarbeitung gewährleistet. Mit dem Bean-Validation-Modell sparen wir Zeit und Aufwand, die andernfalls für das Schreiben einer eigenen Validierungslogik anfallen würden.

Mit Bean Validation können wir mithilfe von Annotationen Einschränkungen für die Eigenschaften eines JavaBeans festlegen. Diese Annotationen können integriert oder benutzerdefiniert sein und Anforderungen an Benutzereingaben definieren, die erfüllt sein müssen, damit diese als gültig gelten. Das Modell verwendet die Einschränkungen anschließend, um das Bean zu validieren und Fehler zu erkennen.

Bean Validation bietet außerdem eine Möglichkeit, Fehler während der Validierung zu behandeln. Das Framework gibt eine Liste mit Constraint-Verstößen zurück, die wir nutzen können, um Benutzern gezieltes Feedback zu geben. Das verbessert die Benutzererfahrung und sorgt für eine robustere und sicherere Anwendung.

Insgesamt ist Bean Validation ein unverzichtbares Werkzeug, um die Qualität und Sicherheit von Java-Anwendungen zu gewährleisten. Wenn wir bei der Verwendung dieses Modells bewährte Methoden befolgen, können wir sicherstellen, dass unsere Anwendungen gut konzipiert, wartbar und sicher sind.