Codename One：如何实现Validator仅验证用户已输入的单个输入项

I get exactly what you're dealing with here—having the validator flag empty fields as errors right off the bat is pretty annoying for users. The good news is we can adjust the logic to only run validation when the user has actually entered (or selected) something. Here are two solid approaches to solve this:

Approach 1: Modify Validator to Skip Empty Inputs by Default #

The simplest fix is to update the validator's validate() method to check if an input has content before applying its constraints. Here's how you can adjust your Validator class:

import java.util.ArrayList;
import java.util.List;

public class Validator {
    private static class ValidationEntry {
        private final InputComponent input;
        private final Constraint constraint;

        public ValidationEntry(InputComponent input, Constraint constraint) {
            this.input = input;
            this.constraint = constraint;
        }

        public InputComponent getInput() {
            return input;
        }

        public Constraint getConstraint() {
            return constraint;
        }
    }

    private final List<ValidationEntry> validationEntries = new ArrayList<>();

    public void addConstraint(InputComponent input, Constraint constraint) {
        validationEntries.add(new ValidationEntry(input, constraint));
    }

    public boolean validate() {
        boolean isFormValid = true;

        for (ValidationEntry entry : validationEntries) {
            InputComponent input = entry.getInput();
            Constraint constraint = entry.getConstraint();
            
            // Check if the input has user-provided content
            boolean hasContent = hasUserContent(input);

            if (hasContent) {
                if (!constraint.isValid(getInputValue(input))) {
                    input.showError(constraint.getErrorMessage());
                    isFormValid = false;
                } else {
                    input.clearError();
                }
            } else {
                // Clear any existing error for empty inputs
                input.clearError();
            }
        }

        return isFormValid;
    }

    // Helper method to check if input has content (adjust based on your component types)
    private boolean hasUserContent(InputComponent input) {
        if (input instanceof TextInput) {
            String text = ((TextInput) input).getText();
            return text != null && !text.trim().isEmpty();
        } else if (input instanceof SelectInput) {
            return ((SelectInput) input).getSelectedOption() != null;
        }
        // Add other input types (checkboxes, radio buttons, etc.) as needed
        return false;
    }

    // Helper method to get the input's value in a consistent format
    private String getInputValue(InputComponent input) {
        if (input instanceof TextInput) {
            return ((TextInput) input).getText();
        } else if (input instanceof SelectInput) {
            return ((SelectInput) input).getSelectedOption().getValue();
        }
        // Handle other input types
        return "";
    }
}

How this works: #

• We added helper methods hasUserContent() and getInputValue() to handle different input types (text fields, selectors, etc.) consistently.
• The validator now only runs constraints on inputs where the user has entered/selected something. Empty inputs won't trigger any error messages.

Approach 2: Add Flexibility with a "Skip Empty" Flag on Constraints #

If you need some constraints to still validate empty fields (like required fields), you can add a configurable flag to your Constraint class. This gives you more control per-field:

public abstract class Constraint {
    private final boolean skipEmpty;

    // Default to skipping empty inputs
    public Constraint() {
        this.skipEmpty = true;
    }

    // Allow overriding the skipEmpty behavior
    public Constraint(boolean skipEmpty) {
        this.skipEmpty = skipEmpty;
    }

    public abstract boolean isValid(String value);
    public abstract String getErrorMessage();

    public boolean shouldSkipEmpty() {
        return skipEmpty;
    }
}

Then update the Validator's validate() method to respect this flag:

public boolean validate() {
    boolean isFormValid = true;

    for (ValidationEntry entry : validationEntries) {
        InputComponent input = entry.getInput();
        Constraint constraint = entry.getConstraint();
        String value = getInputValue(input);
        boolean isEmpty = !hasUserContent(input);

        // Skip validation if empty and the constraint allows it
        if (isEmpty && constraint.shouldSkipEmpty()) {
            input.clearError();
            continue;
        }

        if (!constraint.isValid(value)) {
            input.showError(constraint.getErrorMessage());
            isFormValid = false;
        } else {
            input.clearError();
        }
    }

    return isFormValid;
}

Usage example: #

Now you can specify whether a constraint should validate empty fields:

Validator val = new Validator();
// Make title a required field (don't skip empty validation)
val.addConstraint(title, new LengthConstraint(2, false));
// Only validate price if the user enters something
val.addConstraint(price, new NumericConstraint(true));

Just make sure to adjust the helper methods (hasUserContent() and getInputValue()) to match the actual input components in your codebase—whether they're Swing components, custom UI elements, etc.

内容的提问来源于stack exchange，提问作者Francesco Galgani