💂 ⚗️ 👨🏼‍⚖️ Datenvalidierung: Ein anderer Ansatz ⛰️ 👙 🖖🏼

Das Überprüfen der Daten in der Anwendung, die vom Benutzer eingegeben oder auf andere Weise im klassischen Sinne erhalten wurden, impliziert die Verwendung von nur zwei Ausdrücken im Code: TRUE und FALSE. In einer anderen Ausführungsform werden Ausnahmen verwendet, die eindeutig nicht dafür vorgesehen sind. Gibt es eine bessere Option?

Die Validierung erfolgt durch die sogenannten Validatoren (die nur Teil des gesamten Datenvalidierungsprozesses sind). Der Artikel Servervalidierung von Benutzerdaten bietet eine interessante Version der Validator-Implementierung, es gibt jedoch verschiedene Nuancen in Form der Nachrichtenlokalisierung und des Fehlerformats .

Betrachten Sie zuerst das Fehlerformat.

Der vorgeschlagene Ansatz bezieht sich auf die Validierungsmethode, die die Daten überprüft, um eine Sammlung (Array, Liste usw.) von Zeichenfolgen anstelle von Booleschen Werten oder Auslösen von Ausnahmen zurückzugeben. Ein solches Format wird flexibler und informativer sein.

Ich werde ein Beispiel in Java geben:

import java.util.ArrayList;
import java.util.Collection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public interface ValidateUser {
	String OK = "OK:";
	String FAIL= "FAIL:";
	Collection<String> apply(String username, String password, String email);
	default Collection<String> passwordValidate(String password){
		var result = new ArrayList<String>(1);
		int size = password.trim().length();
		if(size < 3 || size > 20) result.add("Password error:too short value or too long name. Password must be greater or 3 characters and smaller then 20 simbols.");
		return result;
	}
	default Collection<String> usernameValidate(String name){
		var result = new ArrayList<String>(1);
		int size = name.trim().length();
		if(size < 3 || size > 30) result.add("Username error:too short or too long name. Name must be greater or 3 characters and smaller then 30 simbols.");
		return result;
	}
	default Collection<String> emailValidate(String email){
		var result = new ArrayList<String>(1);
		String regex = "^[\\w!#$%&'*+/=?`{|}~^-]+(?:\\.[\\w!#$%&'*+/=?`{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}$";
		Pattern pattern = Pattern.compile(regex);
		Matcher matcher = pattern.matcher(email);
		if (!matcher.find()) result.add("Email error:" + email + " is not valid");
		return result;
	}
	class Default implements ValidateUser{

		@Override
		public Collection<String> apply(String username, String password,
				String email) {
			var errors = passwordValidate(password.trim());
			errors.addAll(usernameValidate(username.trim()));
			errors.addAll(emailValidate(email.trim()));
			return errors;
		}
		
	}
}

Wie Sie hier sehen können, geben alle Methoden eine Sammlung von Zeichenfolgen zurück.

Unit Test Beispiel:

        @Test
	void validateUserTest() {
		
		var validate = new ValidateUser2.Default();
		var result = validate.apply("aaa", "qwe", "aaa@mail.ru");
		assertTrue(result.isEmpty());
		result = validate.apply("aaa", "qwe", "");
		assertFalse(result.isEmpty());
		assertEquals(1, result.size());
		
		result = validate.apply("aa", "qwe", "aaa@mail.ru");
		assertFalse(result.isEmpty());
		assertEquals(1, result.size());
		
		result = validate.apply("aaa", "qwe", "@mail.qweqwe");
		assertFalse(result.isEmpty());
		assertEquals(1, result.size());
		
		result = validate.apply("aa", "qw", "");
		assertFalse(result.isEmpty());
		assertEquals(3, result.size());
	}

Betrachten Sie nun die Lokalisierung von Fehlermeldungen.

Nochmals Beispiel in Java:

public interface LocalizedValidation {
	String OK = "OK:";
	String FAIL= "FAIL:";
	Collection<String> apply(String username, String password, String email, Locale locale);
	default Collection<String> passwordValidate(String password, ResourceBundle bundle){
		var result = new ArrayList<String>(1);
		int size = password.trim().length();
		if(size < 3 || size > 20) result.add(bundle.getString("password"));
		return result;
	}
	default Collection<String> usernameValidate(String name, ResourceBundle bundle){
		var result = new ArrayList<String>(1);
		int size = name.trim().length();
		if(size < 3 || size > 30) result.add(bundle.getString("username"));
		return result;
	}
	default Collection<String> emailValidate(String email, ResourceBundle bundle){
		var result = new ArrayList<String>(1);
		String regex = "^[\\w!#$%&'*+/=?`{|}~^-]+(?:\\.[\\w!#$%&'*+/=?`{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}$";
		Pattern pattern = Pattern.compile(regex);
		Matcher matcher = pattern.matcher(email);
		if (!matcher.find()) result.add(bundle.getString("username")+email);
		return result;
	}
	class Default implements LocalizedValidation{

		@Override
		public Collection<String> apply(String username, String password,
				String email, Locale locale) {
			ResourceBundle bundle = ResourceBundle.getBundle("errors", locale);
			var errors = passwordValidate(password.trim(), bundle);
			errors.addAll(usernameValidate(username.trim(), bundle));
			errors.addAll(emailValidate(email.trim(), bundle));
			return errors;
		}
	}
}


	@Test
	void localizedUserTest() {
		var validate = new LocalizedValidation.Default();
		var result = validate.apply("aaa", "qwe", "aaa@mail.ru", Locale.ENGLISH);
		assertTrue(result.isEmpty());
		result = validate.apply("aaa", "qwe", "", Locale.ENGLISH);
		assertFalse(result.isEmpty());
		assertEquals(1, result.size());
		System.out.println(result.iterator().next());
		
		result = validate.apply("aaa", "qwe", "", new Locale("ru"));
		assertFalse(result.isEmpty());
		assertEquals(1, result.size());
		System.out.println(result.iterator().next());
	}

Lokalisierungsdateien befinden sich in src / main / resources.

error_ru.properties:

mail=Email :   Email:
username=  :     .
password=   :   .

error.properties:

mail=Email error: is not valid:
username=Username error:too short or too long name. Name must be greater or 3 characters and smaller then 30 simbols.
password=Password error:too short value or too long name. Password must be greater or 3 characters and smaller then 20 simbols.

Ich hoffe, dass andere Programmierer, die in ihrer eigenen Sprache schreiben, diesen Ansatz praktisch und bequem finden und ihn zu Hause anwenden können.

PS

Eine Variante der Benutzerauthentifizierungsmethode, die die Implementierung der Schnittstelle java.util.Map.Entry <K, V> zurückgibt und sowohl das Benutzerobjekt als auch Fehlerdaten als Zeichenfolge enthalten kann (dieser Ansatz kann auch verwendet werden, um die Rückgabe von Null von zu vermeiden Methode, wenn das Benutzerobjekt erwartet wird):

@Override
public Entry<String, User> auth(String username, String password, String email) {
	var errors = passwordValidation.apply(password.trim());
	errors.addAll(userNameValidation.apply(username.trim()));
	errors.addAll(emailValidation.apply(email.trim()));
	if(!errors.isEmpty()) {
		return REntry.ofI(null, errors.stream().collect(Collectors.joining(";")));
	}else {
		try {
			var passwordEncrypted = new Encrypt().apply(password.trim());
			var user = new User.Default(0L, username.trim(), email.trim(), passwordEncrypted, "").create(dataSource);
			return REntry.ofI(user, "user is null!");
		} catch (RuntimeException e) {
			return REntry.ofI(null, e.getMessage());
		}
	}
}

Es gibt natürlich einen wunderbaren Artikel über die Validierung in Java auf dem Hub , aber der dort vorgeschlagene Ansatz kann bei weitem nicht in allen Fällen verwendet werden und basiert auf Anmerkungen und Ausnahmen.

Am Ende des Artikels finden Sie einige nützliche Links zum Testen:

Datenvalidierung: Ein anderer Ansatz

More articles: