@Pattern annotation does not work correctly because it runs when i saving the user to the database it validates the hashed password

I will try to force the user their password must have some constraints. So, I use @Pattern annotation to force user to enter the password according to my constraints. But the problem is i send the user data as json from a request and in a service class i change the password with the hashed password. So, the way i saving the user to the database is saving it with the hashed password. So, @Pattern does not validate the actual password but validate the hashed password. So, because it's so long and there are numbers, special charecters, lower and upper case lettters it always validates true. Can you help me with that? When i save the user to the database without hashing the password it work as expected.

So, because it's so long and there are numbers, special charecters, lower and upper case lettters it always validates true. Can you help me with that? When i save the user to the database without hashing the password it work as expected.

Here is my User Model

@Entity
@Getter
@Setter
public class User {
    
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO,generator="native")
    @GenericGenerator(name = "native",strategy = "native")
    private Long userId;

    private String firstname;
    private String lastname;

    @Pattern(regexp = EmailConstants.REGEX_PATTERN, message = EmailConstants.PATTERN_DOES_NOT_MATCH_MESSAGE)
    private String username;

    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    @Pattern(regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9]).{8,}$", message = "try more secure password")
    private String password;

    @JsonIgnore
    @OneToMany (mappedBy = "user", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    private Set<Authority> authorities;
}

And here is my auth Service class that i save the user with the hash password.

@Service
@RequiredArgsConstructor
public class AuthService {

    private final UserService userService;
    private final EmailVerificationService emailVerificationService;

    public User registerUser (User user, PasswordEncoder passwordEncoder) throws Exception {

        String hashPassword = passwordEncoder.encode(user.getPassword());
        user.setPassword(hashPassword);
        Authority authority = new Authority();
        authority.setName(SecurityConstants.ROLE_USER);
        authority.setUser(user);
        Set<Authority> authorities = new HashSet<>();
        authorities.add(authority);
        user.setAuthorities(authorities);
        
        //emailVerificationService.verifyEmail(user.getUsername());
        userService.createUser(user);

        return user;
    }
}

it is a good idea to have different objects for the request model (the data coming in - UserDto) and your domain model (the @Entity you use internally - User).

For example, you can have a UserDto as a simple java class or even a record. This is the request model coming in for creating a user and it can be validated for username and password.

@Value
public class UserDto {
	String firstname;
	String lastname;

	@Pattern(regexp = EmailConstants.REGEX_PATTERN, message = EmailConstants.PATTERN_DOES_NOT_MATCH_MESSAGE)
	String username;

	@Pattern(regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9]).{8,}$", message = "try more secure password")
	String password;
}

Then, you can create a User entity based on this DTO. For example, something like this:

public User buildUser(UserDto dto) {
	User user = new User();
	user.setFirstname(dto.getFirstname());
	user.setLastname(dto.getLastname());
	user.setUsername(dto.getUsername());
	
	String hashPassword = passwordEncoder.encode(dto.getPassword());
	user.setPassword(hashPassword);
	
	Authority authority = new Authority();
	authority.setName(SecurityConstants.ROLE_USER);
	authority.setUser(user);
	Set<Authority> authorities = new HashSet<>();
	authorities.add(authority);
	user.setAuthorities(authorities);
	return user;
}

Additionally, your User class will no longer need the @JsonIgnore (or any other json-related annotations) because now you have spilt the concerns, UserDto will manage the presentation of the class while User will handle the persistence.

PS: in the controller, you will need to add the @Valid annotation. for example:

@PostMapping("users")
public void refisterUser(@Valid @RequestBody UserDto dto) {
   //... 
}

Read more about the DTO design pattern here: https://www.baeldung.com/java-dto-pattern

hope this helps.