Spring Data JPA delete() vs deleteInBatch()

By
Rakesh
-

In this Spring Data JPA tutorial, we will see Spring Data JPA delete() vs deleteInBatch() example using Spring Boot and Oracle.

Spring Data JPA Interview Questions and Answers
How to write a custom method in the repository in Spring Data JPA

Let’s see some points about delete() vs deleteInBatch() method.

The delete() method has been defined in the CrudRepository interface with the following signature.

void delete(T entity);

The deleteInBatch() has been defined in the JpaRepository interface with the following signature.

void deleteInBatch(Iterable<T> entities);

The delete() method internally uses EntityManager’s remove() method as below.

	@Transactional
	public void delete(T entity) {

		em.remove(em.contains(entity) ? entity : em.merge(entity));
	}

The deleteInBatch() internally implemented as below.

	public void deleteInBatch(Iterable<T> entities) {

		applyAndBind(getQueryString(DELETE_ALL_QUERY_STRING, entityInformation.getEntityName()), entities, em)
				.executeUpdate();
	}

Observe both methods implementation. The first one i.e delete() internally uses remove() method. Before call remove() method it calls contains()/merge() method. Then flow will go inside SessionImpl.java class(fireDelete() method) and a lot of stuff happens.

On the other hand, deleteInBatch() prepares the query and collect some other information and directly calls the executeUpdate() method.

With the help of delete() method, we can delete a single record at a time whereas using deleteInBatch() we can delete multiple records.

The delete() method is a little slower as compare deleteInBatch() as delete() does some extra stuff than deleteInBatch().

Let’s see the similarities between delete() vs deleteInBatch() method.

  • Both methods used to delete entities from the database.
  • Both methods throw IllegalArgumentException if entity is null.
  • Both internally annotated with @Transactional annotation.

See more about Transaction Management in Spring here.

We have an example for both methods where we will see how to use Spring Data JPA delete() and deleteInBatch() methods. Also, we will see how much time it takes to delete a record using delete() and deleteInBatch() method.

Let’s see an example of Spring Data JPA delete() vs deleteInBatch() method example.

Open eclipse and create maven project, Don’t forget to check ‘Create a simple project (skip)’ click on next.  Fill all details(GroupId – springdatadeletevsdeleteinbatch, ArtifactId – springdatadeletevsdeleteinbatch  and name – springdatadeletevsdeleteinbatch) and click on finish. Keep packaging as the jar.

Modify pom.xml

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>springdatadeletevsdeleteinbatch</groupId>
	<artifactId>springdatadeletevsdeleteinbatch</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springdatadeletevsdeleteinbatch</name>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.2.RELEASE</version>
	</parent>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>

		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>

		<dependency>
			<groupId>com.oracle</groupId>
			<artifactId>ojdbc6</artifactId>
			<version>11.2.0.3</version>
		</dependency>

	</dependencies>
	<build>
		<finalName>${project.artifactId}</finalName>
		<plugins>

			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<fork>true</fork>
					<executable>C:\Program Files\Java\jdk1.8.0_131\bin\javac.exe</executable>
				</configuration>
			</plugin>


		</plugins>
	</build>
</project>

Note – In pom.xml we have defined javac.exe path in configuration tag. You need to change accordingly i.e where you have installed JDK.

If you see any error for oracle dependency then follow these steps.

Directory structure –

Spring Data JPA delete() vs deleteInBatch()

Student.java

package com.javatute.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Student {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private int id;

	@Column(name = "name")
	private String name;

	@Column(name = "roll_number")
	private String rollNumber;

	@Column(name = "university")
	String university;

	public int getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

	public String getRollNumber() {
		return rollNumber;
	}

	public void setRollNumber(String rollNumber) {
		this.rollNumber = rollNumber;
	}

	public String getUniversity() {
		return university;
	}

	public void setUniversity(String university) {
		this.university = university;
	}

}

StudentController.java

package com.javatute.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.javatute.entity.Student;
import com.javatute.service.StudentService;

@RestController
@RequestMapping(value = "/student")
public class StudentController {

	@Autowired
	private StudentService studentService;

	@RequestMapping(value = "/saveall", method = RequestMethod.POST)
	@ResponseBody
	public List<Student> saveAllStudents(@RequestBody List<Student> studentList) {
		List<Student> studentResponse = (List<Student>) studentService.saveAllStudent(studentList);
		return studentResponse;
	}
	
	@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
	@ResponseBody
	public String delete(@RequestBody Student student) {
		studentService.delete(student);
		return "Student deleted successfully";
	}

	@RequestMapping(value = "/deleteinbatch", method = RequestMethod.DELETE)
	@ResponseBody
	public String deleteInBatch(@RequestBody List<Student> studentList) {
		studentService.deleteInBatch(studentList);
		return "Student deleted successfully";
	}

}

Note – See more details about @Controller and RestController here.

StudentRepository.java – interface

package com.javatute.repository;

import java.io.Serializable;

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

import com.javatute.entity.Student;

@Repository
public interface StudentRepository extends JpaRepository<Student, Serializable> {

}

StudentService.java – interface

package com.javatute.service;

import java.util.List;

import org.springframework.stereotype.Component;

import com.javatute.entity.Student;

@Component
public interface StudentService {
	public List<Student> saveAllStudent(List<Student> studentList);

	public void deleteInBatch(List<Student> student);
	
	public void delete(Student student);

}

Note – See here more about @Component, @Controller, @Service and @Repository annotations here.

StudentServiceImpl.java

package com.javatute.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.javatute.entity.Student;
import com.javatute.repository.StudentRepository;
import com.javatute.service.StudentService;

@Service("studentServiceImpl")
public class StudentServiceImpl implements StudentService {

	@Autowired
	private StudentRepository studentRepository;

	@Transactional
	public List<Student> saveAllStudent(List<Student> studentList) {
		List<Student> response = (List<Student>) studentRepository.saveAll(studentList);
		return response;
	}


	@Transactional
	public void delete(Student student) {
		long start = System.currentTimeMillis();
		studentRepository.delete(student);
		long end = System.currentTimeMillis();
		System.out.println("Time taken by delete--" + (int) (end - start));
	}
	
	@Transactional
	public void deleteInBatch(List<Student> studentList) {
		long start = System.currentTimeMillis();
		studentRepository.deleteInBatch(studentList);
		long end = System.currentTimeMillis();
		System.out.println("Time taken by deleteInBatch--" + (int) (end - start));
	}

}

SpringMain.java

package com.javatute.main;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan(basePackages = "com.*")
@EntityScan("com.javatute.entity")
public class SpringMain {
	public static void main(String[] args) {

		SpringApplication.run(SpringMain.class, args);
	}

}

Note – See more details about @ComponentScan here.

JpaConfig.java

package com.javatute.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@Configuration
@EnableJpaRepositories(basePackages = "com.javatute.repository")
public class JpaConfig {

}

Note – See more details about @Configuration annotations here.

application.properties

# Connection url for the database
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:XE
spring.datasource.username=SYSTEM
spring.datasource.password=oracle2
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
# Show or not log for each sql query
spring.jpa.show-sql = true
 
 
spring.jpa.hibernate.ddl-auto =create
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.Oracle10gDialect
 
server.port = 9091

Let’s run the SpringMain class(run as java application).

Perform saveall operation first using below REST API.

http://localhost:9091/student/saveall

Request Data.

[
    {
        "name": "Hiteshdo",
        "rollNumber": "0126CS01",
        "university":"rgtu"
    },
    {
        "name": "Johnhjhjhjhj",
        "rollNumber": "0126CS02",
        "university":"rgtu"
    },
    {
        "name": "Mohankkkkkkkkkkkkkk",
        "rollNumber": "0126CS03",
        "university":"rgtu"
    },
    {
        "name": "Nagesh",
        "rollNumber": "0126CS04",
        "university":"rgtu"
    },
    {
        "name": "s",
        "rollNumber": "0126CS05",
        "university":"rgtu"
    },
    {
        "name": "Ranakum",
        "rollNumber": "0126CS06",
        "university":"rgtu"
    },
    {
        "name": "Roc",
        "rollNumber": "0126CS07",
        "university":"rgtu"
    },
    {
        "name": "Simpy",
        "rollNumber": "0126CS08",
        "university":"rgtu"
    },
    {
        "name": "Tiwari",
        "rollNumber": "0126CS09",
        "university":"rgtu"
    },    {
        "name": "Appu",
        "rollNumber": "0126CS10",
        "university":"rgtu"
    },
    {
        "name": "Babloo",
        "rollNumber": "0126CS11",
        "university":"rgtu"
    },
    {
        "name": "Ga",
        "rollNumber": "0126CS12",
        "university":"rgtu"
    }
]

Response data –

[
    {
        "id": 1,
        "name": "Hiteshdo",
        "rollNumber": "0126CS01",
        "university": "rgtu"
    },
    {
        "id": 2,
        "name": "Johnhjhjhjhj",
        "rollNumber": "0126CS02",
        "university": "rgtu"
    },
    {
        "id": 3,
        "name": "Mohankkkkkkkkkkkkkk",
        "rollNumber": "0126CS03",
        "university": "rgtu"
    },
    {
        "id": 4,
        "name": "Nagesh",
        "rollNumber": "0126CS04",
        "university": "rgtu"
    },
    {
        "id": 5,
        "name": "s",
        "rollNumber": "0126CS05",
        "university": "rgtu"
    },
    {
        "id": 6,
        "name": "Ranakum",
        "rollNumber": "0126CS06",
        "university": "rgtu"
    },
    {
        "id": 7,
        "name": "Roc",
        "rollNumber": "0126CS07",
        "university": "rgtu"
    },
    {
        "id": 8,
        "name": "Simpy",
        "rollNumber": "0126CS08",
        "university": "rgtu"
    },
    {
        "id": 9,
        "name": "Tiwari",
        "rollNumber": "0126CS09",
        "university": "rgtu"
    },
    {
        "id": 10,
        "name": "Appu",
        "rollNumber": "0126CS10",
        "university": "rgtu"
    },
    {
        "id": 11,
        "name": "Babloo",
        "rollNumber": "0126CS11",
        "university": "rgtu"
    },
    {
        "id": 12,
        "name": "Ga",
        "rollNumber": "0126CS12",
        "university": "rgtu"
    }
]

Perform deleteinbatch operation using below REST API.

http://localhost:9091/student/deleteinbatch

Request Data – Use response data of  http://localhost:9091/student/saveall API.

Spring Data JPA delete() vs deleteInBatch()

Since we have deleted all record, let’s perform save all operation once again. This time we delete one record using delete() and deleteInBaatch() method.

Perform save all operation using –  http://localhost:9091/student/saveall

delete() vs deleteInBatch()

Delete single record using delete() method.

Spring Data JPA delete() vs deleteInBatch()

Delete single record using deleteInBatch() method.

http://localhost:9091/student/deleteinbatch

Hibernate: select student0_.id as id1_0_0_, student0_.name as name2_0_0_, student0_.roll_number as roll_number3_0_0_, student0_.university as university4_0_0_ from student student0_ where student0_.id=?
Time taken by delete–47
Hibernate: delete from student where id=?
Hibernate: delete from student where id=?
Time taken by deleteInBatch–7

Note –  Time taken value might change but delete() should take more time than deleteInBatch().

That’s all about Spring Data JPA delete() vs deleteInBatch().

Summary – The delete() and deleteInBatch() both used to delete entity. Using delete() we can delete a single record where as using deleteInBatch() we can delete multuple records. As comapare to delete(), deleteInBatch() is little fast.

You may like.

Other Spring Data JPA and Hibernate tutorials.

Spring Data JPA deleteInBatch() docs.

RELATED ARTICLESMORE FROM AUTHOR