How to write update query in JPA Repository

Last updated on June 3rd, 2024

We can write an update query in JpaRepository using @Query, @Modifying and @Transactional annotations. For this, we need to create a custom method with the custom query in the interface that extends a JpaRepository interface whose method is annotated with these annotations. Update SQL query returns number after the update of the record in the database that’s why we need to use these three(@Query, @Modifying and @Transactional) annotations on the method of the JpaRepository.

In this topic, we will learn how to write and execute an update query in JpaRepository using the Spring Boot application with Maven, Spring Web, Spring Data JPA, Lombok and H2 database.

To implement this task, create a Spring Boot Restful web service application step-by-step.
These are the following steps:

Creating a Spring Boot Starter Project
Keep the IDE ready
Maven Dependency
Defining the configuration
Creating a JPA Entity
Creating a JPA Repository
Creating a Service Interface
Creating a Service class
Creating a Rest Controller class
Run the Spring Application and Check

1. Creating a Spring Boot Starter Project

We are creating a Spring Boot Application from the web tool Spring Initializr or you can make it from the IDE(STS, VS Code etc.) you are using.
Add the following dependencies:

Spring Web
Spring Data JPA
Lombok
H2 Database

2. Keep the IDE ready

We are importing this created application into our Eclipse IDE or you can import it into another IDE you use. You can refer to this article to create and set up the Spring Boot Project in Eclipse IDE.

Project Structure of Update Query in JpaRepository

3. Maven Dependency

Here is the complete pom.xml file for the Spring Boot Application.
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project
	xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.6.3</version>
		<relativePath />
		<!-- lookup parent from repository -->
	</parent>
	<groupId>com.springjava</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>8</java.version>
	</properties>
	<dependencies>
		<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>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency></dependency>
		<groupId>com.h2database</groupId>
		<artifactId>h2</artifactId>
		<scope>runtime</scope>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

4. Defining the configuration

We are configuring the H2 database configuration in the application.properties file.
application.properties

# H2 Database Configuration
spring.datasource.url=jdbc:h2:mem:test
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update
spring.h2.console.enabled=true

5. Creating a JPA Entity

We are creating a JPA entity class User with these properties(id, name and active).
User.java

package com.springjava.entity;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import lombok.Data;

@Data

@Entity

public class User {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String name;

private String email;

private boolean active;

}

This @Data annotation is used for a constructor, setter method, getter method, etc.
This @Entity annotation is used to create a table through Java code in the database.

6. Creating a JPA Repository

We are creating a JPA Repository to interact with the JPA Entity class. Adding a custom method and update query in the repository.
UserRepository.java

package com.springjava.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.jpa.repository.Modifying;

import org.springframework.data.jpa.repository.Query;

import org.springframework.transaction.annotation.Transactional;

import com.springjava.entity.User;

public interface UserRepository extends JpaRepository<User, Long> {

@Transactional

@Modifying

@Query("update User set active=?1 where id=?2")

int updateUserActive(boolean active, Long id);

}

We have created an update query using @Query with JPQL.
We have added a custom method and it returns type is int.
We used @Modifying annotation because this method returns int after the update query is executed. This annotation is used to enhance the capabilities of @Query of JpaRepository.
We used @Transaction annotation to execute this query in the database.

7. Creating a Service Interface

We are creating a Service interface with some method declaration[save(User user) and updateUserActive(boolean active, Long id)]. So the implementation class of this interface overrides these declared methods.
UserService.java

package com.springjava.service;

import com.springjava.entity.User;

public interface UserService {

void save(User user);

int updateUserActive(boolean active, Long id);

}

8. Creating a Service class

We are creating a Service class UserServiceImpl and this class is implementing the UserService interface. This class is annotated with @Service annotation to act service.
UserServiceImpl.java

package com.springjava.service;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import com.springjava.entity.User;

import com.springjava.repository.UserRepository;

@Service

public class UserServiceImpl implements UserService {

@Autowired

private UserRepository userRepo;

@Override

public void save(User user) {

   userRepo.save(user);

}

@Override

public int updateUserActive(boolean active, Long id) {

return userRepo.updateUserActive(active, id);

}

}

We used @Autowired annotation to inject UserRepository in this service class.
We used save() and updateUserActive() query methods of that JPA Repository.

9. Creating a Rest Controller class

We are creating a RestController class UserController in which all methods are created for API endpoints for handling requests from the clients.
UserController.Java

package com.springjava.controller;

import java.util.LinkedHashMap;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.PutMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import com.springjava.entity.User;

import com.springjava.service.UserService;

@RestController

@RequestMapping("/api/user")

public class UserController {

@Autowired

private UserService userService;

@PostMapping("/save")

public ResponseEntity<?> save(@RequestBody User user) {

Map<String, Object> respUser = new LinkedHashMap<String, Object>();

userService.save(user);

respUser.put("status", 1);

respUser.put("message", "Record is Saved Successfully!");

return new ResponseEntity<>(respUser, HttpStatus.CREATED);

}

@PutMapping("/update/{active}/{id}")

public ResponseEntity<?> updateUserActive(@PathVariable boolean active, @PathVariable Long id) {

Map<String, Object> respUser = new LinkedHashMap<String, Object>();

int record=userService.updateUserActive(active, id);

if (record!=0) {

respUser.put("status", 1);

respUser.put("data", record+" record is updated.");

return new ResponseEntity<>(respUser, HttpStatus.OK);

} else {

respUser.clear();

respUser.put("status", 0);

respUser.put("message", "Data is not found");

return new ResponseEntity<>(respUser, HttpStatus.NOT_FOUND);

}

}

}

This class is annotated with @RestController annotation to make this class act as a Rest Controller for giving responses in JSON form.
We used @RequestMapping annotation to define the base URL for the application.
We used @PostMapping, @PutMapping and @GetMapping annotations to handle HTTP requests from the client.
We used ResponseEntity to represent the entire HTTP response.
We used @Autowired annotation to inject UserService in the class.
We used @RequestBody annotation to take JSON object in the save() method as the User class parameter.
We used @PathVaribale annotation for passing values in the URL to update the record.
We have created two restful web services handling methods[save() and updateUserActive()].
save(): This saves user records into the database.
updateUserActive(): This method is used to update the record in the database by the parameters.

10. Run the Spring Boot Application and Check

Right-click this Spring Boot application on the DemoApplication.java, then click Run As and select Java Application.

Check H2 Database

Check the H2 database console and browse this URL “http://localhost:8080/h2-console”.

See the below table here:

Testing API on the Postman

Saving the user data

POST:http://localhost:8080/api/user/save

Check the table:

Updating user by active field
PUT: http://localhost:8080/api/user/update/false/1