Entity equals ve hashCode — Aynı Sipariş mi?

1
@Entity
2
@Table(name = "transfers")
3
public class Transfer {
4

5
    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE)
6
    private Long id;
7

8
    @Enumerated(EnumType.STRING)
9
    private TransferStatus status = TransferStatus.PENDING;
10

11
    public Long getId() { return id; }
12
    public void markSent() { status = TransferStatus.SENT; }
13

14
    @Override
15
    public boolean equals(Object o) {
16
        if (this == o) return true;
17
        // instanceof accepts Hibernate's proxy subclass; getClass() would not.
18
        if (!(o instanceof Transfer other)) return false;
19
        // Getter, not field: a proxy's fields are empty, getId() is not.
20
        // A new transfer (id == null) equals only itself.
21
        return getId() != null && getId().equals(other.getId());
22
    }
23

24
    @Override
25
    public int hashCode() {
26
        // Constant for the class: the same before and after persist assigns the id,
27
        // and the same for a proxy (getClass().hashCode() would differ).
28
        return Transfer.class.hashCode();
29
    }
30
}

1
@Entity
2
public class Account {
3

4
    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE)
5
    private Long id;
6

7
    @NaturalId                       // unique, immutable; Hibernate adds a unique constraint
8
    @Column(nullable = false, updatable = false, length = 34)
9
    private String iban;
10

11
    private String nickname;         // mutable ("Maaş hesabım"): never part of equals
12
    private BigDecimal balance;      // mutable: never part of equals
13

14
    protected Account() {}
15

16
    public Account(String iban, String nickname) {
17
        this.iban = Objects.requireNonNull(iban);
18
        this.nickname = nickname;
19
        this.balance = BigDecimal.ZERO;
20
    }
21

22
    public String getIban() { return iban; }
23
    public void rename(String nickname) { this.nickname = nickname; }
24

25
    @Override
26
    public boolean equals(Object o) {
27
        if (this == o) return true;
28
        if (!(o instanceof Account other)) return false;
29
        return getIban().equals(other.getIban());
30
    }
31

32
    @Override
33
    public int hashCode() {
34
        return getIban().hashCode();   // known from construction, never changes
35
    }
36
}

1
@Repository
2
class AccountLookup {
3

4
    @PersistenceContext
5
    private EntityManager em;
6

7
    Optional<Account> byIban(String iban) {
8
        return em.unwrap(Session.class)
9
                .bySimpleNaturalId(Account.class)
10
                .loadOptional(iban);
11
    }
12
}

1
@DataJpaTest
2
class TransferEqualityTest {
3

4
    @Autowired TestEntityManager em;
5

6
    @Test
7
    void staysInTheSetAcrossPersist() {
8
        Set<Transfer> set = new HashSet<>();
9
        Transfer transfer = new Transfer();
10
        set.add(transfer);                    // id == null
11
        em.persistAndFlush(transfer);         // id assigned
12
        assertThat(set).contains(transfer);
13
    }
14

15
    @Test
16
    void staysInTheSetWhenAFieldChanges() {
17
        Transfer transfer = em.persistAndFlush(new Transfer());
18
        Set<Transfer> set = new HashSet<>(Set.of(transfer));
19
        transfer.markSent();
20
        assertThat(set).contains(transfer);
21
    }
22

23
    @Test
24
    void twoLoadsOfTheSameRowAreEqual() {
25
        Long id = em.persistAndGetId(new Transfer(), Long.class);
26
        em.flush();
27
        em.clear();
28
        Transfer first = em.find(Transfer.class, id);
29
        em.clear();                        // a second persistence context, in effect
30
        Transfer second = em.find(Transfer.class, id);
31
        assertThat(first).isNotSameAs(second).isEqualTo(second);
32
    }
33

34
    @Test
35
    void theEntityEqualsAProxyOfTheSameRow() {
36
        Long id = em.persistAndGetId(new Transfer(), Long.class);
37
        em.flush();
38
        em.clear();
39
        Transfer proxy = em.getEntityManager().getReference(Transfer.class, id);   // never initialised
40
        em.clear();
41
        Transfer loaded = em.find(Transfer.class, id);
42
        // loaded.equals(proxy) only calls proxy.getId(), which Hibernate answers from
43
        // the proxy itself. (Calling an overridden method like hashCode() on a detached,
44
        // uninitialised proxy would try to load it and fail.)
45
        assertThat(loaded).isEqualTo(proxy);
46
    }
47
}