How should equals and hashcode be implemented when using JPA and Hibernate

I don't think that the accepted answer is accurate.

To answer the original question:

Is the default implementation good enough for most cases?

The answer is yes, in most cases it is.

You only need to override equals() and hashcode() if the entity will be used in a Set (which is very common) AND the entity will be detached from, and subsequently re-attached to, hibernate sessions (which is an uncommon usage of hibernate).

The accepted answer indicates that the methods need to be overriden if either condition is true.

The best equals and hashCode implementation is when you use a unique business key or natural identifier, like this:

@Entity
public class Company {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
 
    @Column(unique = true, updatable = false)
    private String name;
 
    @Override
    public int hashCode() {
        HashCodeBuilder hcb = new HashCodeBuilder();
        hcb.append(name);
        return hcb.toHashCode();
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof Company)) {
            return false;
        }
        Company that = (Company) obj;
        EqualsBuilder eb = new EqualsBuilder();
        eb.append(name, that.name);
        return eb.isEquals();
    }
}

The business key should be consistent across all entity state transitions (transient, attached, detached, removed), that's why you can't rely on id for equality.

Another option is to switch to using UUID identifiers, assigned by the application logic. This way, you can use the UUID for the equals/hashCode because the id is assigned before the entity gets flushed.

You can even use the entity identifier for equals and hashCode, but that requires you to always return the same [hashCode value so that you make sure that the entity hashCode value is consistent across all entity state transitions, like this:

@Entity(name = "Post")
@Table(name = "post")
public class Post implements Identifiable<Long> {
 
    @Id
    @GeneratedValue
    private Long id;
 
    private String title;
 
    public Post() {}
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
 
        if (!(o instanceof Post))
            return false;
 
        Post other = (Post) o;
 
        return id != null &&
               id.equals(other.getId());
    }
 
    @Override
    public int hashCode() {
        return getClass().hashCode();
    }
  
    //Getters and setters omitted for brevity
}

When an entity is loaded through lazy loading, it's not an instance of the base type, but is a dynamically generated subtype generated by javassist, thus a check on the same class type will fail, so don't use:

if (getClass() != that.getClass()) return false;

instead use:

if (!(otherObject instanceof Unit)) return false;

which is also a good practice, as explained on Implementing equals in Java Practices.

for the same reason, accessing directly fields, may not work and return null, instead of the underlying value, so don't use comparison on the properties, but use the getters, since they might trigger to load the underlying values.

Yeah, it's hard. In my project equals and hashCode both rely on the id of the object. The problem of this solution is that neither of them works if the object has not been persisted yet, as the id is generated by database. In my case that's tolerable since in almost all cases objects are persisted right away. Other than that, it works great and is easy to implement.

In the documentation of Hibernate 5.2 it says you might not want to implement hashCode and equals at all - depending on your situation.

https://docs.jboss.org/hibernate/orm/5.2/userguide/html_single/Hibernate_User_Guide.html#mapping-model-pojo-equalshashcode

Generally, two objects loaded from the same session will be equal if they are equal in the database (without implementing hashCode and equals).

It gets complicated if you're using two or more sessions. In this case, the equality of two objects depends on your equals-method implementation.

Further, you'll get into trouble if your equals-method is comparing IDs that are only generated while persisting an object for the first time. They might not be there yet when equals is called.

If you happened to override equals, make sure you fulfill its contracts:-

• SYMMETRY
• REFLECTIVE
• TRANSITIVE
• CONSISTENT
• NON NULL

And override hashCode, as its contract rely on equals implementation.

Joshua Bloch(designer of Collection framework) strongly urged these rules to be followed.

• item 9: Always override hashCode when you override equals

There are serious unintended effect when you don't follow these contracts. For example List#contains(Object o) might return wrong boolean value as the general contract not fulfilled.

Accordin last (Hopefully the final) jpa-buddy investigation, little adapted:

import static org.hibernate.proxy.HibernateProxyHelper.getClassWithoutInitializingProxy;

public abstract class BaseEntity {

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClassWithoutInitializingProxy(this) != getClassWithoutInitializingProxy(o)) return false;
    return getId() != null && getId().equals(((BaseEntity) o).getId());
  }

  @Override
  public final int hashCode() {
    return getClassWithoutInitializingProxy(this).hashCode();
  }

HibernateProxyHelper exist at hibernate-core 5.6.x, but missed at 6.5.x version.

public static Class getClassWithoutInitializingProxy(Object object) {
    return (object instanceof HibernateProxy proxy) ?
            proxy.getHibernateLazyInitializer().getPersistentClass() : object.getClass();
}

You should not override them. It is wrong from a perspective of what an entity is supposed to be.

Why is it wrong to compare entities?

A hibernate-entity (an instance of an entity-class) is your programs representation of an entry in the database (A 'row', in the simplest case of a single SQL-table). This row exists outside of your program logic and memory. It is similar to an object representing a 'file' or a 'thread', it is not contained in your program, it is a proxy to something outside of your program. At what point does it make sense to say that two file-objects are the same? When they represent the same file. But how often do you even compare file-objects? You don't, because the same file should not have two different representations in the same context.

In this way - the hibernate-concept of an "Entity" matches the Domain-Driven-Design (DDD) concept of an entity, which is probably no accident. You can read up on it on SO: What is an Entity? ; Difference Entity vs ValueObject

But isn't an equals/hashcode-contract helpful for disambiguating entities?

Hibernate aims to preserve the abstraction of the entity representing your row. Even if you read the same row from two queries in the same session, it will return the same object again. You can only get two different java-objects representing the same database-row if you detach/reattach or use multiple sessions. This is not a standard usecase of hibernate, but it is entirely possible this happens, for example when multithreading.

So imagine your program finds itself with these two objects:

Person(id=3, name='Sarah', occupation='programmer')
Person(id=3, name='Sarah', occupation='manager')

Which occupation should you continue with for Sarah? Is this an error? Does one version 'win'? You cannot decide just from these two rows, the context of what you are doing matters. And the context to decide this is not included in a HashMap or an entity-class, it is in the code where these two appear.

If you were to define some equality on Person and throw these two objects into the same HashSet or whatever, then one of two things would happen:

1. 'first-save wins' - one version of Sarah gets discarded based on ordering which is probably an implementation-detail of your code

2. You have two conflicting versions of Sarah in your datastructure.

Both are bad. Notice how it doesn't matter how the equality is defined, any general equality would lead to these results - the mistake is not the specific definition of the equality, the mistake is to leave disambiguation to a part of the code that does not have the right context to decide it.

Why are the given approaches wrong?

Two approaches are given in the answers on this site:

1. base equality on a business key
2. Have hashcode always return the same value for all objects of the class
3. base equality on ID

Number 1 might actually work, but bear in mind that business-keys are often immutable in most but not all usecases - the classic example is a user (entity) changing their email-adress (business-key). And keep in mind this doesn't help you resolve ambiguity still, and having an equality that you shouldn't be using is not useful.

Number 2 completely defeats the purpose of hash-based datastructures. It is plain silly to do this. Your HashSets will decay into linked-lists. You are not hashing anything, so you can't have a hashset. I think a lot of people (myself included) did not notice this flaw with the provided implementations because the code looks so careful and advanced (taking care of Proxies and whatnot)

Number 3 works best as ID is the property that actually matches your object to its database-counterpart. It does not work with unpersisted entities so it is limited, and it, too, does not solve the problems mentioned above - you always need custom disambiguation logic if you have two java-objects representing the same database-row. The approach works better if null-IDs (of not-persisted entities) are not a problem. It is possible to generate IDs in the application rather than the database and just never face the situation that an ID field changes. Read the excellent article Don't let hibernate steal your identity to see how this solves the problem.

What should I do instead?

If you feel the need to hash your entities, by using them as keys in a map or as elements in a set, consider these alternatives:

1. Use identity-based collections: IdentityHashMap, IdentityHashSet. They determine equality with reference-equality (==) not .equals()

2. Extract business-keys or IDs and use them as keys. Any Set<Person> can be a Map<PersonKey, Person>, any Map<Person, Something> can be a Map<PersonKey, Something>.

3. Just use a List<Person>, unlike sorting or hashing containers it does not limit mutability of its elements.

4. If you frequently store the same extra-information on your entities in a Map<Person, Extra>, make Extra a transient field on Person

Is this problem exclusive to Hibernate?

There is a very general problem at play here:

You cannot modify an object with respect to its hash-value while it is in a hash-based datastructure (a similar rule holds for sorting-based datastructures). Java, like many other languages, does not have any compiler-rules to help you here. You have to ensure this is true, otherwise your objects get 'lost'. No hibernate here.

Where hibernate comes into play is that it may assign an ID to your object when it saves it, so mutations may happen at places where a beginner may not expect them, but they still happen in a controlled manner.

Making broken and wrong code bearably predictable by silently converting all HashSets into LinkedLists is an incredibly duct-tapey-solution that should not be the recommendation to people asking how to properly write Entity-classes.

There is very nice article here: https://docs.jboss.org/hibernate/stable/core.old/reference/en/html/persistent-classes-equalshashcode.html

Quoting an important line from the article:

We recommend implementing equals() and hashCode() using Business key equality. Business key equality means that the equals() method compares only the properties that form the business key, a key that would identify our instance in the real world (a natural candidate key):

In simple terms

public class Cat {

...
public boolean equals(Object other) {
    //Basic test / class cast
    return this.catId==other.catId;
}

public int hashCode() {
    int result;

    return 3*this.catId; //any primenumber 
}

}