How to implement equals and hashCode using the JPA entity identifier (Primary Key)
Imagine having a tool that can automatically detect JPA and Hibernate performance issues. Wouldn’t that be just awesome?
Well, Hypersistence Optimizer is that tool! And it works with Spring Boot, Spring Framework, Jakarta EE, Java EE, Quarkus, or Play Framework.
So, enjoy spending your time on the things you love rather than fixing performance issues in your production system on a Saturday night!
Introduction
As previously explained, using the JPA entity business key for equals
and hashCode
is always the best choice. However, not all entities feature a unique business key, so we need to use another database column that is also unique as the primary key.
But using the entity identifier for equality is very challenging, and this post is going to show you how you can use it without issues.
Test harness
When it comes to implementing equals
and hashCode
, there is one and only one rule you should have in mind:
Equals and hashCode must behave consistently across all entity state transitions.
To test the effectiveness of an equals
and hashCode
implementation, the following test can be used:
protected void assertEqualityConsistency( Class<T> clazz, T entity) { Set<T> tuples = new HashSet<>(); assertFalse(tuples.contains(entity)); tuples.add(entity); assertTrue(tuples.contains(entity)); doInJPA(entityManager -> { entityManager.persist(entity); entityManager.flush(); assertTrue( "The entity is not found in the Set after it's persisted.", tuples.contains(entity) ); }); assertTrue(tuples.contains(entity)); doInJPA(entityManager -> { T entityProxy = entityManager.getReference( clazz, entity.getId() ); assertTrue( "The entity proxy is not equal with the entity.", entityProxy.equals(entity) ); }); doInJPA(entityManager -> { T entityProxy = entityManager.getReference( clazz, entity.getId() ); assertTrue( "The entity is not equal with the entity proxy.", entity.equals(entityProxy)); }); doInJPA(entityManager -> { T _entity = entityManager.merge(entity); assertTrue( "The entity is not found in the Set after it's merged.", tuples.contains(_entity) ); }); doInJPA(entityManager -> { entityManager.unwrap(Session.class).update(entity); assertTrue( "The entity is not found in the Set after it's reattached.", tuples.contains(entity) ); }); doInJPA(entityManager -> { T _entity = entityManager.find(clazz, entity.getId()); assertTrue( "The entity is not found in the Set after it's loaded in a different Persistence Context.", tuples.contains(_entity) ); }); doInJPA(entityManager -> { T _entity = entityManager.getReference(clazz, entity.getId()); assertTrue( "The entity is not found in the Set after it's loaded as a proxy in a different Persistence Context.", tuples.contains(_entity) ); }); T deletedEntity = doInJPA(entityManager -> { T _entity = entityManager.getReference( clazz, entity.getId() ); entityManager.remove(_entity); return _entity; }); assertTrue( "The entity is not found in the Set even after it's deleted.", tuples.contains(deletedEntity) ); }
Natural id
The first use case to test is the natural id mapping. Considering the following entity:
@Entity public class Book implements Identifiable<Long> { @Id @GeneratedValue private Long id; private String title; @NaturalId private String isbn; @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Book)) return false; Book book = (Book) o; return Objects.equals(getIsbn(), book.getIsbn()); } @Override public int hashCode() { return Objects.hash(getIsbn()); } //Getters and setters omitted for brevity }
The isbn
property is also a @NaturalId
, therefore, it should be unique and not nullable. Both equals
and hashCode
use the isbn
property in their implementations.
For more details about the
@NaturalId
annotation, check out this article.
When running the following test case:
Book book = new Book(); book.setTitle("High-PerformanceJava Persistence"); book.setIsbn("123-456-7890"); assertEqualityConstraints(Book.class, book);
Everything works fine, as expected.
Default java.lang.Object equals and hashCode
What if our entity does not have any column that can be used as a @NaturalId
? The first urge is to not define your own implementations of equals
and hashCode
, like in the following example:
@Entity(name = "Book") public class Book implements Identifiable<Long> { @Id @GeneratedValue private Long id; private String title; //Getters and setters omitted for brevity }
However, when testing this implementation:
Book book = new Book(); book.setTitle("High-PerformanceJava Persistence"); assertEqualityConstraints(Book.class, book);
Hibernate throws the following exception:
java.lang.AssertionError: The entity is not found after it's merged
The original entity is not equal to the one returned by the merge method because two distinct Object(s) do not share the same reference.
Using the entity identifier for equals and hashCode
So if the default equals
and hashCode
is no good either, then let’s use the entity identifier for our custom implementation. Let’s just use our IDE to generate the equals
and hashCode
and see how it works:
@Entity public class Book implements Identifiable<Long> { @Id @GeneratedValue private Long id; private String title; @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Book)) return false; Book book = (Book) o; return Objects.equals(getId(), book.getId()); } @Override public int hashCode() { return Objects.hash(getId()); } //Getters and setters omitted for brevity }
When running the previous test case, Hibernate throws the following exception:
java.lang.AssertionError: The entity is not found after it's persisted
When the entity was first stored in the Set, the identifier was null. After the entity was persisted, the identifier was assigned to a value that was automatically generated. Hence the hashCode differs. For this reason, the entity cannot be found in the Set after it got persisted.
Fixing the entity identifier equals and hashCode
To address the previous issue, there is only one solution: the hashCode should always return the same value:
@Entity public class Book implements Identifiable<Long> { @Id @GeneratedValue private Long id; private String title; @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Book)) return false; Book other = (Book) o; return id != null && id.equals(other.getId()); } @Override public int hashCode() { return getClass().hashCode(); } //Getters and setters omitted for brevity }
Also, when the entity identifier is null
, we can guarantee equality only for the same object references. Otherwise, no transient object is equal to any other transient or persisted object. That’s why the identifier equality check is done only if the current Object
identifier is not null.
With this implementation, the equals
and hashCode
test runs fine for all entity state transitions. The reason why it works is that the hashCode value does not change. Hence, we can rely on the java.lang.Object
reference equality as long as the identifier is null
.
Why using a constant hashCode is not a performance issue for JPA entities
If your entities are stored in a List
, then the hashCode
is not going to be used when adding or removing elements from the List
.
If you are using a Set
or a Map
to store entities, the hashCode
is used to determine the bucket where the entity will be stored. Ideally, you want to use as many buckets as possible to improve the performance of finding a given element.
However, this requirement is needed when you have very large collections that are stored in the application memory.
The performance of the contains
method when using a Set
with a single bucket can be visualized in the following table:
| Collection size | Count duration [milliseconds] | |-----------------|-------------------------------| | 250 | 0.006 | | 1,000 | 0.069 | | 5,000 | 0.092 | | 10,000 | 0.25 | | 25,000 | 0.49 | | 50,000 | 0.862 |
So, to have a 1 millisecond extra overhead, we need a Set
with more than 50k entries.
But in order to have 50k entities in the application memory, we first need to fetch them from the database. And fetching 50k entries can take hundreds of milliseconds.
So, in reality, we can only fetch a limited number of records, as otherwise, we would have a performance issue no matter how the hashCode
method was implemented.
To reduce the collection size, we use SQL pagination, and we will only fetch way less than 1000 records at a time because even 1000 elements may be too much for your business use case since the UI has a limited viewport that makes it hard to display more than 50 or 100 elements at a time.
However, calling contains
on a Set
with 250 elements takes only 6 microseconds, and that’s far from being an issue considering that, in many non=trivial applications, it’s not uncommon to find SQL queries that take hundreds of milliseconds to execute.
So, since we are bound to use small data sets in OLTP transactions, having a constant hashCode
for our entities is not really a problem.
I'm running an online workshop on the 11th of October about High-Performance SQL.If you enjoyed this article, I bet you are going to love my Book and Video Courses as well.
Conclusion
The entity identifier can be used for equals
and hashCode
, but only if the hashCode
returns the same value all the time. This might sound like a terrible thing to do since it defeats the purpose of using multiple buckets in a HashSet
or HashMap
.
However, for performance reasons, you should always limit the number of entities that are stored in a collection. You should never fetch thousands of entities in a @OneToMany
Set
because the performance penalty on the database side is multiple orders of magnitude higher than using a single hashed bucket.
All tests are available on GitHub.

Interesting read and nice explanations.
One question, the “Identifiable” interface you are implementing in a couple of the examples. Is that an interface you have defined yourself, or is it from a dependency/framework that should be used as well?
It’s an interface that I created myself so that the test suite can work independently of the entity version we are testing.
For more details, check out the tests on GitHub:
https://github.com/vladmihalcea/high-performance-java-persistence/tree/master/core/src/test/java/com/vladmihalcea/hpjp/hibernate/equality