Custom validator annotation in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when validating a field with a custom annotation?

Consider a Spring Boot application with a custom annotation @StartsWithA that validates if a string starts with the letter 'A'. What happens when a field annotated with @StartsWithA contains the value "Apple"?

Spring Boot

public class Fruit {
    @StartsWithA
    private String name;

    // constructor, getters, setters
}

// Assume @StartsWithA is correctly implemented to check if the string starts with 'A'.

A Validation passes because "Apple" starts with 'A'.

B Validation fails because custom annotations require manual validation calls.

C Validation fails because "Apple" is not exactly 'A'.

D Validation passes only if the field is public.

💡 Hint

Think about what the custom validator checks and the value given.

The custom validator checks if the string starts with 'A'. Since "Apple" starts with 'A', validation passes.

📝 Syntax

intermediate

Which option correctly defines a custom validator annotation in Spring Boot?

You want to create a custom annotation @StartsWithA to validate strings starting with 'A'. Which option shows the correct annotation definition?

A

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = StartsWithAValidator.class)
public class StartsWithA {
    String message() default "Must start with A";
}

B

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.CLASS)
@Constraint(validatedBy = StartsWithAValidator.class)
public @interface StartsWithA {
    String message() default "Must start with A";
}

C

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface StartsWithA {
    String message() default "Must start with A";
}

D

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = StartsWithAValidator.class)
public @interface StartsWithA {
    String message() default "Must start with A";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

💡 Hint

Remember that custom annotations for validation must specify target, retention, and the validator class.

Option D correctly uses @Target, @Retention, and @Constraint with validatedBy, and defines required elements for a validation annotation.

🔧 Debug

advanced

Why does the custom validator not trigger during validation?

Given a custom annotation and validator, the validation does not trigger when saving an entity. What is the most likely cause?

Spring Boot

public class User {
    @StartsWithA
    private String username;

    // getters and setters
}

// Validator class and annotation are implemented correctly.

A The annotation is missing the @Documented meta-annotation.

B The field username is private and needs to be public for validation.

C The validator class is not registered as a Spring bean or not referenced correctly in the annotation.

D The validation only works on controller methods, not on entity fields.

💡 Hint

Check how Spring Boot finds and uses validator classes.

If the validator class is not properly linked or registered, Spring Boot won't run it during validation.

❓ state_output

advanced

What is the validation error message when the input fails the custom validator?

If a field annotated with @StartsWithA(message = "Must start with A letter") contains "Banana", what error message will be shown?

A Must start with A

B Must start with A letter

C Validation failed for field username

D Banana is invalid

💡 Hint

Look at the message attribute in the annotation.

The message attribute in the annotation overrides the default message and is shown on validation failure.

🧠 Conceptual

expert

Why use custom validator annotations instead of manual validation in Spring Boot?

Which is the best reason to create a custom validator annotation rather than manually checking values in service methods?

A Custom annotations integrate with Spring's validation framework, enabling automatic checks and error reporting.

B Manual validation is faster and more reliable than annotations.

C Custom annotations require less code but cannot be reused.

D Manual validation is the only way to validate complex objects.

💡 Hint

Think about integration and reusability benefits.

Custom validator annotations work with Spring's validation system, allowing automatic validation and consistent error handling across the app.

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