Custom validator annotation in Spring Boot - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a custom validator annotation in Spring Boot?

It is a user-defined annotation used to add specific validation rules to fields or methods beyond built-in validations.

beginner

Which interface must be implemented to create a custom validator in Spring Boot?

The interface javax.validation.ConstraintValidator must be implemented to define the validation logic.

intermediate

What two elements are required in a custom validator annotation definition?

1. @Target to specify where the annotation can be applied (e.g., fields). 2. @Retention to specify annotation lifetime (usually RUNTIME).

intermediate

How do you link a custom annotation to its validator class?

Use the @Constraint(validatedBy = YourValidatorClass.class) annotation on the custom annotation definition.

beginner

Why use custom validator annotations instead of simple methods?

They integrate with Spring Boot's validation framework, allowing automatic validation during data binding and clear error messages.

What annotation is used to specify the validator class for a custom annotation?

A @Validated

B @Valid

C @Constraint

D @Target

The @Constraint annotation links the custom annotation to its validator class.

Which method must be implemented in a ConstraintValidator?

A isValid

B validate

C check

D apply

The isValid method contains the logic to check if the value is valid.

Where should a custom validator annotation be applied?

A Only on constructors

B Only on classes

C Only on packages

D On fields or methods

Custom validator annotations are typically applied on fields or methods to validate their values.

What retention policy is usually used for custom validator annotations?

A CLASS

B RUNTIME

C SOURCE

D MODULE

RUNTIME retention allows the annotation to be available during program execution for validation.

Which package contains the ConstraintValidator interface?

A javax.validation

B org.springframework.validation

C java.validation

D org.hibernate.validator

javax.validation.ConstraintValidator is the standard interface for custom validators.

Explain the steps to create a custom validator annotation in Spring Boot.

Think about annotation setup and validator class connection.

Why is it beneficial to use custom validator annotations instead of manual validation in Spring Boot?

Consider automation and reusability.

Practice

1. What is the main purpose of creating a custom validator annotation in Spring Boot?

easy

A. To define your own validation rules reusable across your application

B. To replace built-in annotations like @NotNull completely

C. To automatically generate database tables

D. To handle HTTP requests in controllers

Solution

1. Step 1: Understand the role of custom validator annotations

   They allow you to create your own rules for validating data beyond built-in checks.

2. Step 2: Identify the main benefit

   These annotations keep validation logic clean and reusable across different parts of your app.

3. Final Answer:

   To define your own validation rules reusable across your application -> Option A

4. Quick Check:

   Custom validator = reusable validation rules [OK]

Hint: Custom validators create reusable rules, not replace built-ins [OK]

Common Mistakes:

• Thinking custom validators replace all built-in annotations
• Confusing validation with database or HTTP handling
• Assuming custom validators auto-generate code

2. Which of the following is the correct way to declare a custom validator annotation interface in Spring Boot?

easy

A. @Validator class MyValidator { String message() default "Invalid"; }

B. class MyValidator { String message() default "Invalid"; }

C. interface MyValidator { void validate(); }

D. @interface MyValidator { String message() default "Invalid"; Class[] groups() default {}; Class[] payload() default {}; }

Solution

1. Step 1: Recall the syntax for custom annotation interfaces

   They use @interface keyword and define methods like message(), groups(), and payload().

2. Step 2: Check each option

   @interface MyValidator { String message() default "Invalid"; Class[] groups() default {}; Class[] payload() default {}; } correctly uses @interface and includes required methods. Others either use wrong keywords or miss required parts.

3. Final Answer:

   @interface MyValidator { String message() default "Invalid"; Class[] groups() default {}; Class[] payload() default {}; } -> Option D

4. Quick Check:

   Custom annotation = @interface + standard methods [OK]

Hint: Custom annotations use @interface with message, groups, payload [OK]

Common Mistakes:

• Using class or interface instead of @interface
• Omitting groups() or payload() methods
• Adding methods unrelated to validation

3. Given this validator class snippet, what will happen when validating a string with value "abc123"?

public class AlphaValidator implements ConstraintValidator<Alpha, String> {
  public boolean isValid(String value, ConstraintValidatorContext context) {
    return value != null && value.matches("^[a-zA-Z]+$");
  }
}

medium

A. Validation throws a NullPointerException

B. Validation passes because the string contains letters

C. Validation fails because the string contains digits

D. Validation always returns true regardless of input

Solution

1. Step 1: Analyze the validation logic

   The method checks if the string is not null and matches the regex "^[a-zA-Z]+$", which means only letters allowed.

2. Step 2: Test the input "abc123" against the regex

   Since "abc123" contains digits, it does not match the regex, so the method returns false.

3. Final Answer:

   Validation fails because the string contains digits -> Option C

4. Quick Check:

   Regex allows only letters, digits cause failure [OK]

Hint: Check regex carefully; digits break letter-only pattern [OK]

Common Mistakes:

• Assuming partial match passes validation
• Ignoring null check in code
• Thinking digits are allowed by regex

4. You wrote a custom validator but it always passes validation even for invalid data. Which of these is the most likely cause?

medium

A. The annotation interface is missing the @Target annotation

B. The isValid method always returns true regardless of input

C. The validator class does not implement ConstraintValidator

D. The message() method in the annotation returns an empty string

Solution

1. Step 1: Understand the role of isValid method

   This method contains the validation logic and must return true only for valid inputs.

2. Step 2: Identify why validation always passes

   If isValid always returns true, invalid data will pass unchecked.

3. Final Answer:

   The isValid method always returns true regardless of input -> Option B

4. Quick Check:

   isValid controls validation result; always true means always pass [OK]

Hint: Check isValid method return values first when validation fails [OK]

Common Mistakes:

• Forgetting to implement ConstraintValidator interface
• Missing @Target causes compile warnings but not always validation failure
• Empty message() affects error text, not validation logic

5. You want to create a custom validator annotation @StartsWith that checks if a string starts with a given prefix. Which combination of elements is required to implement this correctly?

hard

A. An annotation interface with a String prefix() method, a validator class implementing ConstraintValidator<StartsWith, String>, and overriding isValid to check the prefix

B. An annotation interface with int length(), a validator class implementing Validator, and overriding validate to check length

C. A class annotated with @Component that implements ConstraintValidator without an annotation interface

D. An annotation interface with String suffix(), a validator class implementing ConstraintValidator<EndsWith, String>, and overriding isValid to check suffix

Solution

1. Step 1: Define the annotation interface with a prefix parameter

   The annotation must declare a method String prefix() to accept the prefix value.

2. Step 2: Implement the validator class correctly

   The validator class must implement ConstraintValidator<StartsWith, String> and override isValid to check if the string starts with the given prefix.

3. Final Answer:

   An annotation interface with a String prefix() method, a validator class implementing ConstraintValidator<StartsWith, String>, and overriding isValid to check the prefix -> Option A

4. Quick Check:

   Annotation + validator class + isValid checking prefix = correct [OK]

Hint: Match annotation method and validator generic types carefully [OK]

Common Mistakes:

• Using wrong method names like suffix() for prefix check
• Implementing wrong interfaces or missing annotation interface
• Confusing validate() with isValid() method names