如何在DAO中同时使用Spring验证注释（Bean验证规范）

Question

I have a User Entity and it's using Spring Validation Annotation[Edited - Bean Validation Specification] as follow.

@NotEmpty(message = "{warn.null.user.password}")
private String            password;

This validation is ok when I am using for Registration Action, But I tried to use the same Entity(User) by different Action called Update and I want to void @NotEmpty Annotation. How can I do that?

Regards.

Answer 1

I have a User Entity and it's using Spring Validation Annotation as follow.

First of all, it's not "Spring Validation Annotation". These are annotations from the Bean Validation Specification (known as JSR-303 and JSR-349). Some annotations a non-standard and supplied by the validation provider (for example, Hibernate Validator).

But I tried to use the same Entity(User) by different Action called Update and I want to void @NotEmpty Annotation

It could be achieved by using groups attribute of the annotation. In first scenario you will run all groups and in another scenario only some of them. Unfortunately, the Specification (currently) doesn't support that (because @Valid doesn't allow to provide groups ).

Here is where Spring's non-standard annotation @Validated comes to the rescue: you can specify validation groups with it!

But it works only for validation models in the controller. It doesn't work as validation before persisting entity to the database because there is no way to specify groups ( Default group always used).

As an example, you can use this question: Hibernate-validator Groups with Spring MVC

Answer 2

You could remove the validation from the user entity in your domain model and move it to the service layer. This makes more sense because the validation of the entity depends on the context.

In your example, there are 2 use cases:

• a user should be able to register

• a user should be able to change his data for example his password.

Then this can be modeled like in the code below.

 public class User {

        private final String email;
        private String password;

        public User(final String email, final String password) {

            this.email = email;
            this.password = password;
        }

        public void changePassword(final String password) {
            this.password = password;
        }

        public String getEmail() {
            return email;
        }

        public String getPassword() {
            return password;
        }

    }

This also has the advantage that your domain model is not dependent on an external library.

You can move the validations from the domain layer to the service layer where the validation depends on the action that is performed. There is a registration command and an update command.

When a user registers, the email and the password should not be empty.

public class RegisterUserCommand {

    @NotEmpty(message = "{warn.null.user.email}")
    private String email;
    @NotEmpty(message = "{warn.null.user.password}")
    private String password;
    ...

The update command only requires that the email is not empty

public class UpdateUserCommand {

    @NotEmpty(message = "{warn.null.user.email}")
    private String email;
    private String password;
    ...

In the service layer you can then do something like:

public class UserService {

    private final UserDao userDao;

    public UserService(final UserDao userDao){
        this.userDao = userDao;
    }

    public User register(final RegisterUserCommand command) {
        User user = new User(command.getEmail(), command.getPassword());
        return userDao.save(user);
    }

    public User update(final UpdateUserCommand command) {
        User user = userDao.findUserByEmail(command.getEmail());
        user.changePassword(command.getPassword);
        return user;

    }

}

This is of course only an example because I don't know how the rest of your code is implemented.