Convalida basata su annotazione Spring 3: password e conferma password

Question

Nella mia applicazione Spring 3 MVC, gli utenti devono salvare una password e sarebbe una buona funzionalità se fossero in grado di confermare la password al momento del salvataggio.

Nel bean sto usando la convalida basata sull'annotazione. È disponibile un validatore di annotazioni per eseguire questo controllo?

Dopo alcuni googleing ho trovato questo blog: http://gochev.blogspot.com/2010/06/spring-mvc-spring-bean-validation.html. Ma immagino che mi manchi un jar-lib qui perché Eclipse non è in grado di trovare/suggerire alcun vaso. Qualcuno sa di quale barattolo ho bisogno perché funzioni?

Grazie in anticipo :)

Answer 1

È necessario il barattolo 303 Api Hibernate Validazione e JSR.

<dependency> 
     <groupId>org.hibernate</groupId> 
     <artifactId>hibernate-validator</artifactId> 
     <version>4.1.0.Final</version>       
    </dependency> 
    <dependency> 
     <groupId>javax.validation</groupId> 
     <artifactId>validation-api</artifactId> 
     <version>1.0.0.GA</version> 
    </dependency> 

• http://mvnrepository.com/artifact/org.hibernate/hibernate-validator
• http://mvnrepository.com/artifact/javax.validation/validation-api/1.0.0.GA

Vedere questa domanda: Cross field validation with Hibernate Validator (JSR 303)

ci sono diversi modi per affrontare questo problema.

Answer 2

ho scritto quanto segue al fine di convalidare le password: implementazione

Vincolo:

package com.test.web.validation.user; 

import java.lang.annotation.Documented; 
import java.lang.annotation.ElementType; 
import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 
import java.lang.annotation.Target; 

import javax.validation.Constraint; 
import javax.validation.Payload; 

@Target({ ElementType.TYPE }) 
@Retention(RetentionPolicy.RUNTIME) 
@Documented 
@Constraint(validatedBy = PasswordsEqualConstraintValidator.class) 
public @interface PasswordsEqualConstraint { 
String message(); 

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

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

package com.test.web.validation.user; 

import javax.validation.ConstraintValidator; 
import javax.validation.ConstraintValidatorContext; 

import com.test.logic.dto.UserDto; 

public class PasswordsEqualConstraintValidator implements 
    ConstraintValidator<PasswordsEqualConstraint, Object> { 

@Override 
public void initialize(PasswordsEqualConstraint arg0) { 
} 

@Override 
public boolean isValid(Object candidate, ConstraintValidatorContext arg1) { 
    UserDto user = (UserDto) candidate; 
    return user.getPassword().equals(user.getPasswordRepeat()); 
} 
} 

mio DTO Oggetto:

package com.test.logic.dto; 

import java.io.Serializable; 
import java.util.ArrayList; 
import java.util.Date; 
import java.util.List; 

import javax.validation.constraints.NotNull; 
import javax.validation.constraints.Size; 

import com.esldic.web.validation.user.EmailExistsConstraint; 
import com.esldic.web.validation.user.PasswordsEqualConstraint; 

@PasswordsEqualConstraint(message = "passwords are not equal") 
public final class UserDto extends AbstractDto implements Serializable { 

private static final long serialVersionUID = 1L; 

private Long id; 

@NotNull 
@Size(min = 3, max = 30) 
@EmailExistsConstraint(message = "email is not available") 
private String email; 

private String username; 

@NotNull 
@Size(min = 2, max = 30) 
private String password; 

@NotNull 
@Size(min = 2, max = 30) 
private String passwordRepeat; 
... 
} 

Infine, il mio controller

package com.test.web.controllers; 

import java.util.Set; 

import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse; 
import javax.validation.ConstraintViolation; 
import javax.validation.Validator; 

import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Controller; 
import org.springframework.web.bind.annotation.ModelAttribute; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RequestMethod; 
import org.springframework.web.bind.annotation.ResponseBody; 
import org.springframework.web.servlet.ModelAndView; 

import com.test.logic.dto.UserDto; 

@Controller 
public final class SignupController { 

@Autowired 
private Validator validator; 

@RequestMapping(value = "/signup.html", method = RequestMethod.POST) 
public @ResponseBody 
ModelAndView handleSignupForm(@ModelAttribute UserDto candidate, 
     HttpServletResponse response) throws ServiceException { 
    Set<ConstraintViolation<UserDto>> failures = validator 
      .validate(candidate); 

    if (!failures.isEmpty()) { 
     response.setStatus(HttpServletResponse.SC_BAD_REQUEST); 
     return ValidationHelper.validationMessages(failures); 

    } else { 
     return userService.create(candidate); 
    } 
} 

Inoltre, in google troverai molti esempi con la convalida del bean JSR-303.

Answer 3

La soluzione accettata data da Cyril Deba ha funzionato anche per me. Ma poi ho dovuto fare un'altra annotazione per ResetPassword e ChangePassword Page, dato che hanno DTO diversi. Per superare che ho cambiato è valido sotto il codice. Anche se potrebbe essere raggiunto implementando anche un'interfaccia, ma penso che questo sia più realistico. Spero che ti sarà d'aiuto.

@Override 
public boolean isValid(Object candidate, ConstraintValidatorContext context) { 

    try { 
     Method methodGetPassword = candidate.getClass().getMethod("getPassword"); 
     Method methodGetConfirmpassword = candidate.getClass().getMethod("getConfirmpassword"); 

     if(methodGetPassword.invoke(candidate) == null && methodGetConfirmpassword.invoke(candidate)==null) 
      return true; 
     else if(methodGetPassword.invoke(candidate) == null) 
      return false; 
     return methodGetPassword.invoke(candidate).equals(methodGetConfirmpassword.invoke(candidate)); 

    } catch (NoSuchMethodException ex) { 
     ex.printStackTrace(); 
     return false; 
    } catch (Exception ex) { 
     ex.printStackTrace(); 
     return false; 
    } 
}