Spring Boot @Modifying Example

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

1. Introduction

When working with Spring Data JPA repositories, it's common to create custom query methods that can modify the state of the database. The @Modifying annotation in Spring Boot is used in conjunction with @Query to enhance the query method so that it can perform not just select operations but also insert, update, and delete operations. This blog post will showcase an example of using the @Modifying annotation within a Spring Boot application.

Key Points:

1. @Modifying is used on JPA repository methods to indicate that a method should execute a modifying query.

2. It is typically used with @Query annotation for writing custom update or delete queries.

3. Methods annotated with @Modifying must be used within a transactional context.

4. @Modifying can be combined with @Transactional to execute the query within a transaction.

5. After executing a modifying query, it is often necessary to clear the underlying persistence context to synchronize it with the result of the executed operation.

2. Implementation Steps

1. Add Spring Data JPA dependency to your project.

2. Create an entity class and a repository interface for that entity.

3. In the repository interface, define a method with @Modifying and @Query annotations to perform a modifying operation.

4. Use @Transactional to wrap the modifying operation in a transaction.

5. Call the custom repository method from your service or controller class.

3. Implementation Example

// Step 1: Add Spring Data JPA dependency to your build configuration
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>	
    <artifactId>h2</artifactId>
    <version>2.2.224</version>
    <scope>test</scope>
</dependency>
        
// Step 2: Create an entity class
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
    // Constructors, getters, and setters
}

// Step 3: Create a repository interface for the User entity
public interface UserRepository extends JpaRepository<User, Long> {

    // Step 4: Define a modifying query to update user email
    @Modifying
    @Query("UPDATE User u SET u.email = :email WHERE u.id = :id")
    int updateUserEmail(@Param("id") Long id, @Param("email") String email);
}

// Step 5: Use the custom repository method in a service class
@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Transactional
    public int updateEmail(Long userId, String newEmail) {
        return userRepository.updateUserEmail(userId, newEmail);
    }
}

// Step 6: Create a controller class to expose an endpoint for the update operation
@RestController
public class UserController {

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @PostMapping("/users/{id}/email")
    public ResponseEntity<String> updateEmail(@PathVariable Long id, @RequestBody String email) {
        int count = userService.updateEmail(id, email);
        return count == 1 ? ResponseEntity.ok("Email updated successfully.") :
                ResponseEntity.status(HttpStatus.NOT_MODIFIED).body("Email update failed.");
    }
}

// Step 7: Run the application
@SpringBootApplication
public class ModifyingAnnotationExampleApplication {

    public static void main(String[] args) {
        SpringApplication.run(ModifyingAnnotationExampleApplication.class, args);
    }
}

// You can now test the email update feature by sending a POST request to /users/{id}/email

Output:

Email updated successfully.

Explanation:

1. @Entity and @Id: These annotations define the User class as a JPA entity and mark the id field as the primary key.

2. UserRepository: This is a Spring Data JPA repository interface for the User entity.

3. @Modifying: This annotation is applied to the updateUserEmail method to allow the @Query to perform a data modification operation.

4. @Query: It's used to specify a custom JPQL update statement that updates the email of a User.

5. @Param: It is used to bind method parameters to query parameters.

6. UserService: A service class that invokes the modifying query method. It is marked with @Transactional to execute the method within a transaction context.

7. UserController: A controller class that handles HTTP requests to update a User's email.

8. @Transactional: This annotation ensures that the operation occurs within a transactional context.

9. @SpringBootApplication: It denotes the main application class that enables auto-configuration and component scanning.

10. @RestController and @PostMapping: Annotations used to define a REST endpoint that handles POST requests for updating user email.

11. SpringApplication.run(): This static method bootstraps the Spring Boot application, including the

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Java Guides

Search This Blog