How do you perform updates using the @Modifying annotation in Spring Data JPA?

Table of Contents

• Introduction
• What is the @Modifying Annotation?
  • Key Points:
• How to Perform Updates Using @Modifying Annotation
  • 1. Basic Update Query with **@Modifying**
    • Example: Updating a Single Field
    • Example Usage:
  • 2. Updating Multiple Fields Using **@Modifying**
    • Example: Updating Multiple Fields
  • 3. Delete Operation Using **@Modifying**
  • 4. Updating Using Native SQL Queries
    • Example: Native SQL Update Query
  • 5. Using **@Transactional** with **@Modifying**
    • Example: Using @Transactional with @Modifying
  • 6. Flushing and Clearing the Persistence Context
    • Example: Flushing after Update
  • Conclusion

Introduction

In Spring Data JPA, updating an entity is often done through the repository’s built-in methods, but there are cases where you may need to execute custom update queries. The **@Modifying** annotation plays a critical role in these cases, as it marks methods that modify the database, such as update or delete operations. By default, Spring Data JPA treats repository methods as read-only, meaning they execute select queries. The @Modifying annotation instructs Spring Data to execute a modifying query (e.g., UPDATE, DELETE) instead of a SELECT query.

This guide explains how to use the @Modifying annotation to perform updates in Spring Data JPA, covering both basic use cases and advanced scenarios.

What is the @Modifying Annotation?

The @Modifying annotation is used in combination with the @Query annotation to indicate that a query will modify the database (e.g., update, delete, or insert operations). When you annotate a repository method with @Modifying, Spring Data JPA knows that the query will modify data, and it adjusts the query execution process accordingly.

Key Points:

• **@Modifying**: Tells Spring Data JPA that the query is an update, delete, or insert query.
• **@Query**: Specifies the custom JPQL (Java Persistence Query Language) or SQL query to execute.
• **flush** and **clear**: Optionally, you can use @Modifying with @Transactional to manage persistence contexts during and after the update.

How to Perform Updates Using @Modifying Annotation

1. Basic Update Query with **@Modifying**

In a typical use case, you might want to update a specific field in an entity. Here's how to do it using a custom JPQL query with @Modifying:

Example: Updating a Single Field

Assume you have an entity Book with fields id, title, and author. You want to update the author field of a book based on its id.

Now, create a custom update query using @Modifying:

• **@Modifying**: Marks this query as an update.
• **@Query**: Defines the JPQL query to update the author of a Book based on its id.
• Return type **int**: The method returns the number of rows affected by the update. It is useful to know how many entities were updated.

Example Usage:

• **updateAuthorById**: This method will update the author of the Book entity with id equal to 1L to "New Author".
• The method returns the number of updated rows.

2. Updating Multiple Fields Using **@Modifying**

You can also update multiple fields in a single query using @Modifying.

Example: Updating Multiple Fields

• This query updates both the title and author fields of a Book entity.
• Return type **int**: It returns the number of affected rows.

3. Delete Operation Using **@Modifying**

@Modifying is not limited to update operations. It is also used to delete data. For example, to delete books by author name:

• This query will delete all books with the specified author.

4. Updating Using Native SQL Queries

If your update logic is complex or requires specific SQL syntax not supported by JPQL, you can use native SQL queries with @Modifying.

Example: Native SQL Update Query

• **nativeQuery = true**: This tells Spring Data JPA that the query is a native SQL query rather than JPQL.
• This query will update the author field in the books table (note the use of the table name instead of the entity name).

5. Using **@Transactional** with **@Modifying**

By default, **@Modifying** works within the context of a transaction. However, for some operations (e.g., if you're performing multiple updates), it is a good practice to explicitly specify **@Transactional** to ensure the changes are committed correctly.

Example: Using @Transactional with @Modifying

• **@Transactional**: Ensures that the update query runs within a transaction and the changes are committed to the database.

6. Flushing and Clearing the Persistence Context

After executing a modifying query, the persistence context (the first-level cache) might not reflect the updated state of the entity immediately. You can control this behavior using **flush** and **clear**.

Example: Flushing after Update

• **@Transactional** ensures the operation is executed within a transaction.
• After the update, the persistence context is flushed automatically, ensuring that the updated data is synchronized with the database.

Conclusion

The **@Modifying** annotation in Spring Data JPA is an essential tool for performing update, delete, and insert operations through custom queries. By using @Modifying with @Query, you can execute JPQL or native SQL queries that modify database records. When combined with **@Transactional**, you can ensure data consistency and commit changes in a controlled manner. Additionally, @Modifying can be used to update single or multiple fields, perform batch updates, and even delete records, making it a versatile solution for managing updates in Spring Data JPA applications.