Nella convalida MVC di primavera, è possibile visualizzare solo un messaggio di errore per campo alla volta?

Question

Esempio,

Ho

@NotEmpty //tells you 'may not be empty' if the field is empty 
@Length(min = 2, max = 35) //tells you 'length must be between 2 and 35' if the field is less than 2 or greater than 35 
private String firstName; 

Poi ingresso un valore vuoto.

E dice: 'non può essere vuoto lunghezza deve essere compresa tra 2 e 35'

E 'possibile dire primavera per convalidare una alla volta per ogni campo?

Answer 1

Sì, è possibile. Basta creare il proprio annotazione in questo modo:

@Documented 
@Constraint(validatedBy = {}) 
@Target({ ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE }) 
@Retention(RetentionPolicy.RUNTIME) 
@ReportAsSingleViolation 
@NotEmpty 
@Length(min = 2, max = 35) 
public @interface MyAnnotation { 

    public abstract String message() default "{mypropertykey}"; 

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

    public abstract Class<?>[] payload() default {}; 
} 

parte importante è l'annotazione @ReportAsSingleViolation

Answer 2

Una soluzione migliore sarebbe quella di avere dei markup nel messaggio di errore in modo che si formuli bene, come ad esempio un <br />, e utilizzare una classe CSS per formattare il messaggio generale. Come notato nel commento di Bozho, un utente dovrebbe essere consapevole di tutto ciò che è errato.

Answer 3

vincoli Usa personalizzate per il vostro campo. Ad esempio, utilizzerà annotazione @StringField.

@Target(ElementType.FIELD) 
@Constraint(validatedBy = StringFieldValidator.class) 
@Retention(RetentionPolicy.RUNTIME) 

public @interface StringField { 

    String message() default "Wrong data of string field"; 

    String messageNotEmpty() default "Field can't be empty"; 

    String messageLength() default "Wrong length of field"; 

    boolean notEmpty() default false; 

    int min() default 0; 

    int max() default Integer.MAX_VALUE; 

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

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

Quindi creare una logica nella classe StringFieldValidator. Questa classe è implementata da un'interfaccia ConstraintValidator <A extends Annotation, T>.

public class StringFieldValidator implements ConstraintValidator<StringField, String> { 

    private Boolean notEmpty; 
    private Integer min; 
    private Integer max; 
    private String messageNotEmpty; 
    private String messageLength; 

    @Override 
    public void initialize(StringField field) { 
     notEmpty = field.notEmpty(); 
     min = field.min(); 
     max = field.max(); 
     messageNotBlank = field.messageNotEmpty(); 
     messageLength = field.messageLength(); 
    } 

    @Override 
    public boolean isValid(String value, ConstraintValidatorContext context) { 
     context.disableDefaultConstraintViolation(); 
     if (notEmpty && value.isEmpty()) { 
      context.buildConstraintViolationWithTemplate(messageNotEmpty).addConstraintViolation(); 
      return false; 
     } 
     if ((min > 0 || max < Integer.MAX_VALUE) && (value.length() < min || value.length() > max)) { 
      context.buildConstraintViolationWithTemplate(messageLength).addConstraintViolation(); 
      return false; 
     } 
     return true; 
    } 
} 

Quindi è possibile utilizzare annotazioni come:

@StringField(notEmpty = true, min = 6, max = 64, 
      messageNotEmpty = "Field can't be empty", 
      messageLength = "Field should be 6 to 64 characters size") 

E dopo tutto, si avrà solo un messaggio di errore indicato in giusto ordine.