Validation groups in Spring Boot - Mini Project: Build & Apply

Using Validation Groups in Spring Boot

📖 Scenario: You are building a simple user registration system where different validation rules apply depending on whether the user is registering or updating their profile.

🎯 Goal: Create a Spring Boot application that uses validation groups to apply different validation rules for user registration and user update operations.

📋 What You'll Learn

Create a User class with fields username, email, and password

Define two validation groups: RegisterGroup and UpdateGroup

Apply validation annotations to User fields with groups

Create a controller method that validates User using the RegisterGroup

Create a controller method that validates User using the UpdateGroup

💡 Why This Matters

🌍 Real World

Validation groups let you reuse the same data model but apply different rules depending on the action, like registration or update forms.

💼 Career

Understanding validation groups is important for backend developers working with Spring Boot to build robust APIs with flexible validation.

1

Create the User class with fields

Create a class called User with three private fields: username of type String, email of type String, and password of type String. Include public getters and setters for each field.

Spring Boot

public class User {
    // Your code here
}

Hint

Define private fields and generate public getter and setter methods for each.

2

Define validation groups interfaces

Create two empty interfaces called RegisterGroup and UpdateGroup in the same package as User. These will be used as validation groups.

Spring Boot

public interface RegisterGroup {
    // Your code here
}

public interface UpdateGroup {
    // Your code here
}

Hint

Interfaces for validation groups are empty marker interfaces.

3

Add validation annotations with groups to User fields

In the User class, add validation annotations with groups: annotate username with @NotBlank(groups = RegisterGroup.class), annotate email with @Email(groups = {RegisterGroup.class, UpdateGroup.class}), and annotate password with @NotBlank(groups = RegisterGroup.class). Import necessary validation annotations.

Spring Boot

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;

public class User {
    // Add validation annotations with groups here
    private String username;
    private String email;
    private String password;

    // getters and setters
}

// RegisterGroup and UpdateGroup interfaces remain unchanged

Hint

Use @NotBlank and @Email annotations with the groups attribute to specify validation groups.

4

Create controller methods validating with groups

Create a Spring REST controller class called UserController. Add two methods: registerUser and updateUser. Both accept a @RequestBody User user. Annotate registerUser parameter with @Validated(RegisterGroup.class) and updateUser parameter with @Validated(UpdateGroup.class). Both methods return String confirming success.

Spring Boot

import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

@RestController
public class UserController {
    // Add registerUser method here

    // Add updateUser method here
}

Hint

Use @Validated(Group.class) on method parameters to apply validation groups.

Practice

1. What is the main purpose of using validation groups in Spring Boot?

easy

A. To automatically generate validation error messages

B. To group multiple objects for batch validation

C. To disable validation temporarily

D. To apply different validation rules to the same object based on context

Solution

1. Step 1: Understand validation groups concept

   Validation groups allow applying different sets of validation rules to the same object depending on the situation.

2. Step 2: Compare with other options

   Grouping objects or disabling validation are not the purpose of validation groups. Generating messages is separate.

3. Final Answer:

   To apply different validation rules to the same object based on context -> Option D

4. Quick Check:

   Validation groups = Different rules per context [OK]

Hint: Validation groups separate rules by use case [OK]

Common Mistakes:

• Thinking groups batch multiple objects
• Assuming groups disable validation
• Confusing groups with error message generation

2. Which of the following is the correct way to define a validation group interface in Spring Boot?

easy

A. @Group public interface CreateGroup {}

B. public class CreateGroup {}

C. public interface CreateGroup {}

D. interface CreateGroup extends Validation {}

Solution

1. Step 1: Recall validation group definition

   Validation groups are defined as empty interfaces without annotations or inheritance.

2. Step 2: Analyze options

   public interface CreateGroup {} correctly defines an empty interface. public class CreateGroup {} uses class, which is incorrect. @Group public interface CreateGroup {} uses a non-existent annotation. interface CreateGroup extends Validation {} extends a non-required interface.

3. Final Answer:

   public interface CreateGroup {} -> Option C

4. Quick Check:

   Groups = empty interfaces [OK]

Hint: Groups are simple empty interfaces [OK]

Common Mistakes:

• Using classes instead of interfaces
• Adding unnecessary annotations
• Extending unrelated interfaces

3. Given the code snippet:

@NotNull(groups = CreateGroup.class)
private String name;

@NotNull(groups = UpdateGroup.class)
private String id;

What happens when you validate the object with @Validated(CreateGroup.class)?

medium

A. Only the id field is validated for not null

B. Only the name field is validated for not null

C. Both name and id fields are validated for not null

D. No fields are validated because groups are ignored

Solution

1. Step 1: Understand group-based validation

   When validating with CreateGroup.class, only constraints assigned to that group run.

2. Step 2: Check which fields have CreateGroup

   The name field has @NotNull(groups = CreateGroup.class), so it is validated. The id field belongs to UpdateGroup, so it is skipped.

3. Final Answer:

   Only the name field is validated for not null -> Option B

4. Quick Check:

   Validate CreateGroup = only name checked [OK]

Hint: Validate with group runs only matching group constraints [OK]

Common Mistakes:

• Assuming all fields validate regardless of group
• Confusing group names
• Ignoring group parameter in validation

4. Consider this validation setup:

@NotNull(groups = Default.class)
private String email;

@NotBlank(groups = AdminGroup.class)
private String role;

Why does validation fail to check email when validating with @Validated(AdminGroup.class)?

medium

A. Because email is in the Default group, not AdminGroup

B. Because @NotNull is ignored in groups

C. Because role is not validated

D. Because @Validated does not support groups

Solution

1. Step 1: Identify groups assigned to fields

   The email field uses the Default group, while role uses AdminGroup.

2. Step 2: Understand validation group filtering

   When validating with AdminGroup.class, only constraints in that group run. email is skipped because it belongs to Default.

3. Final Answer:

   Because email is in the Default group, not AdminGroup -> Option A

4. Quick Check:

   Validation group filters constraints [OK]

Hint: Default group constraints don't run if validating other groups [OK]

Common Mistakes:

• Assuming Default group always validates
• Thinking @NotNull ignores groups
• Believing @Validated ignores groups

5. You want to validate a user object differently when creating and updating. You have CreateGroup and UpdateGroup. How do you apply validation groups to a Spring Boot controller method to validate only the create rules?

hard

A. Use @Validated(CreateGroup.class) on the method parameter

B. Use @Valid without groups on the method parameter

C. Use @Validated without parameters on the method parameter

D. Use @Validated(UpdateGroup.class) on the method parameter

Solution

1. Step 1: Recall how to specify validation groups

   To validate with a specific group, use @Validated(GroupName.class) on the method parameter.

2. Step 2: Match group to desired validation

   For create rules, use CreateGroup.class. Using @Valid or @Validated without parameters runs default group only.

3. Final Answer:

   Use @Validated(CreateGroup.class) on the method parameter -> Option A

4. Quick Check:

   Specify group in @Validated to run that group's rules [OK]

Hint: Add group class to @Validated to run specific validations [OK]

Common Mistakes:

• Using @Valid which ignores groups
• Omitting group class in @Validated
• Using wrong group class for validation