delete() vs deleteById() in Spring Data JPA

Spring Data JPA aims to significantly improve the implementation of data access layers by reducing the effort to the amount that's actually needed. As a developer, you write your repository interfaces, including custom finder methods, and Spring will provide the implementation automatically.

Spring Data JPA provides delete() and deleteById() methods to delete the particular. While their intentions might seem similar at first, they cater to slightly different use cases. 

Let's first quickly take a look into the overview of these methods and then we will discuss the key differences between them. 

1. delete() 

Method Signature:

void delete(T entity);
Where T is the domain type the repository manages. 


The delete() method removes a given entity directly from the database. 


You use the delete() method when you already have an instance of the entity. This method is handy when you've fetched an entity, perhaps for verification or modification, and then you decide to remove it.


Student student = studentRepository.findById(1L).orElse(null);
if(student != null && "John".equals(student.getName())) {


You need to have an instance of the entity. It does not throw an exception if the entity doesn't exist in the database. However, if the entity has unsaved changes, it can lead to unexpected outcomes.

2. deleteById() 

Method Signature:

void deleteById(ID id);
Where ID is the type of the id of the entity the repository manages. 


deleteById() aims to delete an entity based solely on its primary key (ID). 


When you only have the ID and not the complete entity, deleteById() is your go-to method. It saves you the overhead of fetching the complete entity before deletion.




You only need to know the ID of the entity you wish to delete. If the given ID does not exist, the method throws an EmptyResultDataAccessException

3. Key Differences

Entity Requirement: 

delete(): Requires the full entity. 

deleteById(): Just needs the entity's ID. 

Exception Handling: 

delete(): Doesn't throw an exception for non-existent entities. 

deleteById(): Throws an exception if you attempt to delete using a non-existent ID. 


delete(): This could be less efficient if you first need to fetch the entity from the database only to delete it. 

deleteById(): More efficient when you want to delete an entity, and you already know its ID without needing to fetch it. 

4. Conclusion

Both delete() and deleteById() have their places in Spring Data JPA. While delete() is suited for scenarios where the entity instance is available, deleteById() shines when you only possess the ID. By understanding the distinctions and the best scenarios for each method, developers can ensure more efficient and error-free database operations.