Spring Data JPA @Modifying Annotation: A Step-by-Step Tutorial

Author:
The @Modifying annotation in Spring Data JPA is used to enhance the @Query annotation for executing update and delete queries. This annotation is necessary when performing any modification to the database as it marks the query as an update or delete query. This tutorial will guide you through the process of using the @Modifying annotation in a Spring Boot application with Spring Data JPA.

Prerequisites

  • JDK 17 or later
  • Maven or Gradle
  • IDE (IntelliJ IDEA, Eclipse, etc.)

Step 1: Set Up a Spring Boot Project

1.1 Create a New Spring Boot Project

Use Spring Initializr to create a new project with the following dependencies:

  • Spring Web
  • Spring Data JPA
  • H2 Database (or any other database of your choice)

Download and unzip the project, then open it in your IDE.

1.2 Configure application.properties

Set up the application properties for your project. This file is located in the src/main/resources directory.

# src/main/resources/application.properties

# H2 Database configuration
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.datasource.platform=h2

# JPA configuration
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Explanation:

  • Configures the H2 in-memory database.
  • Enables SQL logging.
  • Sets up JPA to update the database schema automatically.

Step 2: Define the Entity Class

2.1 Create the User Entity

Create an entity class to represent a user in the database.

package com.example.demo.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
    private int age;

    // Getters and setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Explanation:

  • @Entity: Specifies that the class is an entity and is mapped to a database table.
  • @Id and @GeneratedValue: Indicates the primary key and its generation strategy.

Step 3: Create the Repository Interface

3.1 Create the UserRepository

Create a repository interface to perform CRUD operations on the User entity and define custom update and delete queries using the @Modifying annotation.

package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

    @Modifying
    @Transactional
    @Query("UPDATE User u SET u.email = :email WHERE u.id = :id")
    int updateEmailById(@Param("id") Long id, @Param("email") String email);

    @Modifying
    @Transactional
    @Query("DELETE FROM User u WHERE u.age > :age")
    int deleteUsersOlderThan(@Param("age") int age);
}

Explanation:

  • @Repository: Indicates that the interface is a Spring Data repository.
  • @Modifying: Marks the query as an update or delete query.
  • @Transactional: Ensures that the query is executed within a transaction.
  • updateEmailById: Updates the email of a user by their ID using JPQL.
  • deleteUsersOlderThan: Deletes users older than a specified age using JPQL.

Step 4: Create Service and Controller Layers

4.1 Create the UserService

Create a service class to handle business logic related to users.

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public Optional<User> getUserById(Long id) {
        return userRepository.findById(id);
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }

    public int updateUserEmail(Long id, String email) {
        return userRepository.updateEmailById(id, email);
    }

    public int deleteUserOlderThan(int age) {
        return userRepository.deleteUsersOlderThan(age);
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

Explanation:

  • @Service: Marks the class as a service component in Spring.
  • UserRepository: Injected to interact with the database.

4.2 Create the UserController

Create a REST controller to expose endpoints for interacting with users.

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/{id}")
    public Optional<User> getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @PutMapping("/{id}/email")
    public int updateUserEmail(@PathVariable Long id, @RequestParam String email) {
        return userService.updateUserEmail(id, email);
    }

    @DeleteMapping("/older-than/{age}")
    public int deleteUserOlderThan(@PathVariable int age) {
        return userService.deleteUserOlderThan(age);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

Explanation:

  • @RestController: Marks the class as a REST controller.
  • @RequestMapping("/users"): Maps the controller to /users endpoint.
  • @GetMapping, @PostMapping, @PutMapping, @DeleteMapping: Maps HTTP GET, POST, PUT, and DELETE requests respectively.
  • @RequestBody: Binds the HTTP request body to the User parameter.
  • @PathVariable: Binds the URI template variable to the method parameter.
  • @RequestParam: Binds the query parameter to the method parameter.

Step 5: Running and Testing the Application

5.1 Run the Application

Run the Spring Boot application using your IDE or the command line:

./mvnw spring-boot:run

5.2 Test the Endpoints

Use a tool like Postman or your browser to test the endpoints.

Create a User

  • URL: http://localhost:8080/users
  • Method: POST
  • Body: 
    {
    "name": "Ramesh Fadatare",
    "email": "ramesh.fadatare@example.com",
    "age": 30
}

Get All Users

  • URL: http://localhost:8080/users
  • Method: GET

Get a User by ID

  • URL: http://localhost:8080/users/{id}
  • Method: GET

Update a User's Email

  • URL: http://localhost:8080/users/{id}/email
  • Method: PUT
  • Params: email=new.email@example.com

Delete Users Older Than a Certain Age

  • URL: http://localhost:8080/users/older-than/{age}
  • Method: DELETE

Delete a User

  • URL: http://localhost:8080/users/{id}
  • Method: DELETE

Conclusion

In this tutorial, you have learned how to use the @Modifying annotation in a Spring Boot 3.2 application with Spring Data JPA to define custom update and delete queries. We covered:

  • Setting up a Spring Boot project with Spring Data JPA.
  • Defining an entity class and repository with custom update and delete queries.
  • Creating service and controller layers.
  • Running and testing the application using REST endpoints.

By following these steps, you can easily implement custom update and delete operations in your Spring Boot applications using Spring Data JPA.

Comments

Post a Comment

Leave Comment