Convalida Spring vs Hibernate validation using annotation

Question

sto creando un'applicazione demo utilizzando mvc 3.0 molla. Devo applicare la convalida sullo schermo. Eseguo ricerche sulla rete e ho scoperto che sono principalmente utilizzati 2 tipi di convalida con applicazione: - convalide

1. molla con le convalide Api
2. validazione Hibernate usando Hibernate convalide

Speriamo che qualcuno mi danno il suggerimento che uno è buono per implementare nell'applicazione.

Answer 1

Ho usato entrambi - Mi piace la convalida di ibernazione di più - abbastanza facile da implementare e piuttosto standard. Viene abilitato automaticamente quando si ha un'implementazione sul classpath. Ecco un esempio:

@EmailValidator 
@NotBlank 
@Length(max=65) 
private String email; 

Da dove viene il messaggio Error String? In WEB-INF è necessario disporre di un file chiamato messages.properties:

NotBlank.ForgotPasswordBackingObject.email=Email address must be present 

C'è un'annotazione @Email standard, ma una e-mail come ad esempio: @ MyCompany mi viene considerato valido, per questo ho dovuto fare il mio own @EmailValidator (ha cambiato un regex flag da * a + nell'implementazione standard). Ci sono alcuni problemi che ho trovato: l'ordine dei convalida - che convalida che vuoi che accada prima, questo è fatto con i gruppi di convalida, ma questo non è possibile con l'annotazione @Valid, ad esempio:

@RequestMapping(method=RequestMethod.POST, value="/auth/changePassword") 
public ModelAndView submitChangePasswordPage(@Valid @ModelAttribute("ChangePasswordBackingObject") ChangePasswordBackingObject backingObject, BindingResult result, Principal principal) 

Ecco perché se hai il tuo Controller in questo formato (in Spring MVC per esempio), allora devi simulare la tua logica in un modo - l'ho fatto anche io.

Un'altra cosa interessante che si può fare per convalidare due o più campi in al momento (che ho trovato molto utile):

@FieldMatch.List({ 
    @FieldMatch(firstValue = "password" , secondValue = "confirmPassword") 
}) 
public class RequestAccountBackingObject implements Serializable { 
    private String password; 
    private String confirmPassword; 

e l'implementazione:

@Target({TYPE, ANNOTATION_TYPE}) 
@Retention(RUNTIME) 
@Constraint(validatedBy = FieldMatchImpl.class) 
@Documented 
public @interface FieldMatch{ 
    String message() default "{com.errorMessage}"; 
    Class<?>[] groups() default {}; 
    Class<? extends Payload>[] payload() default {}; 
    String firstValue(); 
    String secondValue(); 
    @Target({TYPE, ANNOTATION_TYPE}) 
    @Retention(RUNTIME) 
    @Documented 
    @interface List 
    { FieldMatch[] value(); } 
} 

L'altro FieldMatchImpl sarebbe:

public class FieldMatchImpl implements ConstraintValidator<FieldMatch, Object>{ 
    private String firstFieldName; 
    private String secondFieldName; 

ed hai bisogno di due metodi implementati:

public void initialize(final FieldMatch constraintAnnotation){ 
    firstFieldName = constraintAnnotation.firstValue(); 
    secondFieldName = constraintAnnotation.secondValue(); 

anche:

public boolean isValid(final Object value, final ConstraintValidatorContext context){ 

    final String firstObj = BeanUtils.getProperty(value, firstFieldName); 
    final String secondObj = BeanUtils.getProperty(value, secondFieldName); 

Utilizzando org.apache.commons.beanutils.BeanUtils ora è possibile convalidare i due campi.

Ti piace questa:

boolean result = firstObj.equals(secondObj); 
if(!result) { 
    context.disableDefaultConstraintViolation(); 
    context.buildConstraintViolationWithTemplate(errorMessage).addNode(firstFieldName).addConstraintViolation(); 
} 

Altri poi che è stato un piacere utilizzando la convalida Hibernate finora.