package jakarta.validation.constraints;
 
/**
 * The annotated element must not be {@code null}.
 * Accepts any type.
 *
 * @author Emmanuel Bernard
 */
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Retention(RUNTIME)
@Repeatable(List.class)
@Documented
@Constraint(validatedBy = { })
public @interface NotNull {
 
	String message() default "{jakarta.validation.constraints.NotNull.message}";
 
	Class<?>[] groups() default { };
 
	Class<? extends Payload>[] payload() default { };
 
	/**
	 * Defines several {@link NotNull} annotations on the same element.
	 *
	 * @see jakarta.validation.constraints.NotNull
	 */
	@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
	@Retention(RUNTIME)
	@Documented
	@interface List {
 
		NotNull[] value();
	}
}

@Pattern(regexp = "[0-9]*")
@Size(min = 5, max = 5)
@Constraint(validatedBy = FrenchZipCodeValidator.class)
@Documented
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Retention(RUNTIME)
public @interface FrenchZipCode {
 
    String message() default "Wrong zip code";
 
    Class<?>[] groups() default {};
 
    Class<? extends Payload>[] payload() default {};
}

public interface ConstraintValidator<A extends Annotation, T> {
 
	/**
	 * Initializes the validator in preparation for
	 * {@link #isValid(Object, ConstraintValidatorContext)} calls.
	 * The constraint annotation for a given constraint declaration
	 * is passed.
	 * <p>
	 * This method is guaranteed to be called before any use of this instance for
	 * validation.
	 * <p>
	 * The default implementation is a no-op.
	 *
	 * @param constraintAnnotation annotation instance for a given constraint declaration
	 */
	default void initialize(A constraintAnnotation) {
	}
 
	/**
	 * Implements the validation logic.
	 * The state of {@code value} must not be altered.
	 * <p>
	 * This method can be accessed concurrently, thread-safety must be ensured
	 * by the implementation.
	 *
	 * @param value object to validate
	 * @param context context in which the constraint is evaluated
	 *
	 * @return {@code false} if {@code value} does not pass the constraint
	 */
	boolean isValid(T value, ConstraintValidatorContext context);
}

package org.hibernate.validator.internal.constraintvalidators.bv;
 
/**
 * Validate that the object is not {@code null}.
 *
 * @author Emmanuel Bernard
 */
public class NotNullValidator implements ConstraintValidator<NotNull, Object> {
 
	@Override
	public boolean isValid(Object object, ConstraintValidatorContext constraintValidatorContext) {
		return object != null;
	}
}

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

@Slf4j
@RestController
public class AccountController {
 
    /**
     * Create account
     *
     * @param accountRequest account request
     * @return response with account id
     */
    @PostMapping("/api/createAccount")
    public Response<String> createAccount(@Validated(value = {Default.class, Create.class}) @RequestBody AccountRequest accountRequest) {
        log.info("Create account: {}", accountRequest);
        // TODO: Create account
        return Response.success("123456");
    }
 
    @PostMapping("/api/updateAccount")
    public Response<String> updateAccount(@Validated(value = {Default.class, Update.class}) @RequestBody AccountRequest accountRequest) {
        log.info("Update account: {}", accountRequest);
        // TODO: Update account
        return Response.success(accountRequest.getAccountId());
    }
}

@Data
public class AccountRequest implements Serializable {
 
    /**
     * Account id, required for update
     */
    @NotNull(message = "Account Id is required for update", groups = {Update.class})
    private String accountId;
 
    /**
     * Account number, should be unique, length should be less than 32
     */
    @NotNull(message = "Account No is required")
    @Size(max = 32, message = "Account No length should be less than 32")
    @UniqueAccountNo(groups = {Create.class})
    private String accountNo;
 
    /**
     * Account name, should not be empty, length should be less than 100
     */
    @NotNull(message = "Account Name is required")
    @Size(max = 100, message = "Account Name length should be less than 100")
    private String accountName;
 
    /**
     * Account type, should be one of [SAVING, CURRENT, FIXED]
     */
    @NotNull(message = "Account Type is required")
    @InEnum(value = AccountTypeEnum.class, message = "Account Type should be one of [SAVING, CURRENT, FIXED]")
    private String accountType;
 
    /**
     * Account balance, should not be null, should be greater than 0
     */
    @NotNull(message = "Account Balance is required")
    @Range(min = 0, message = "Account Balance should be greater than 0")
    private BigDecimal balance;
 
    /**
     * Account expiration date, should be in the future
     */
    @NotNull(message = "Account Expiration Date is required")
    @Future(message = "Account Expiration Date should be in the future")
    private Date expireDate;
 
    /**
     * Address list, should not be empty
     */
    @Valid
    @NotNull(message = "Address List should not be empty")
    @Size(min = 1, message = "Address List should not be empty")
    private List<@NotNull AddressInfo> addressList;
}

@Data
public class AddressInfo implements Serializable {
 
    /**
     * Address Type, should be one of [HOME, OFFICE]
     */
    @NotNull(message = "Address Type is required")
    @InEnum(value = AddressTypeEnum.class, message = "Address Type should be one of [HOME, OFFICE]")
    private String addressType;
 
    /**
     * Address, should not be empty, length should be less than 200
     */
    @NotNull(message = "Address is required")
    @Size(max = 200, message = "Address length should be less than 200")
    private String address;
 
    /**
     * Zip code, should not be empty, length should be 6 digits
     */
    @NotNull(message = "Zip Code is required")
    @Pattern(regexp = "^[0-9]{6}$", message = "Zip Code should be 6 digits")
    private String zipCode;
 
    /**
     * Mobile phone number, should not be empty, length should be 11
     */
    @NotNull(message = "Mobile Phone Number is required")
    @Pattern(regexp = "^1[0-9]{10}$", message = "Mobile Phone Number should be 11 digits")
    private String mobilePhoneNo;
}

@Target({FIELD, CONSTRUCTOR, PARAMETER})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = InEnumValidator.class)
public @interface InEnum {
 
    /**
     * Enum class
     *
     * @return enum class
     */
    Class<? extends BaseEnum> value();
 
    String message() default "accountNo must be unique";
 
    Class<?>[] groups() default {};
 
    Class<? extends Payload>[] payload() default {};
}

public class InEnumValidator implements ConstraintValidator<InEnum, String> {
 
    private Class<? extends BaseEnum> enumClass;
 
    @Override
    public void initialize(InEnum constraintAnnotation) {
        enumClass = constraintAnnotation.value();
    }
 
    @Override
    public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) {
        if (enumClass == null) {
            return false;
        }
 
        for (BaseEnum baseEnum : enumClass.getEnumConstants()) {
            if (baseEnum.getCode().equals(s)) {
                return true;
            }
        }
 
        return false;
    }
}

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
 
    public static final String ILLEGAL_PARAMETERS = "ILLEGAL_PARAMETERS";
 
    @ExceptionHandler(value = MethodArgumentNotValidException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public <T> Response<T> handlerMethodArgumentNotValidException(MethodArgumentNotValidException e) {
        log.error("MethodArgumentNotValidException occur!!!", e);
        return Response.fail(ILLEGAL_PARAMETERS,
                e.getBindingResult().getFieldErrors().stream()
                        .map(FieldError::getDefaultMessage).collect(Collectors.joining("; ")));
    }
}