• 无ID属性
    • 判断相等的方法只能是抽象方法

    值对象没有ID属性，也就没有对应字段，这意味着我们没办法在基类中判断两个值对象是否相等。为了判断其结构相等，我们可以在基类中构建基础方法：

    1. package com.lugew.springbootddd;
    3. /**
    4.  * @author 夏露桂
    5.  * @since 2021/6/8 17:40
    6.  */
    7. public abstract class ValueObject<T> {
    8.     @Override
    9.     public boolean equals(Object obj) {
    10.         T valueObject = (T) obj;
    11.         if (valueObject == null)
    12.             return false;
    13.         return equalsCore(valueObject);
    14.     }
    16.     @Override
    17.     public int hashCode() {
    18.         return getHashCodeCore();
    19.     }
    21.     protected abstract boolean equalsCore(T other);
    23.     protected abstract int getHashCodeCore();
    24. }

    可以看到我们重写了equals和hashCode方法，并且将具体的实现委托给了其子类。此时，我们可以将Money类进行重构：

    1. package com.lugew.springbootddd.snackmachine;
    3. import com.lugew.springbootddd.ValueObject;
    5. /**
    6.  * @author 夏露桂
    7.  * @since 2021/6/7 11:59
    8.  */
    10. public class Money extends ValueObject<Money> {
    11.     private final int oneCentCount;
    12.     private final int tenCentCount;
    13.     private final int quarterCount;
    14.     private final int oneDollarCount;
    15.     private final int fiveDollarCount;
    16.     private final int twentyDollarCount;
    18.     public Money(int oneCentCount, int tenCentCount, int quarterCount, int
    19.             oneDollarCount, int fiveDollarCount, int twentyDollarCount) {
    20.         this.oneCentCount = oneCentCount;
    21.         this.tenCentCount = tenCentCount;
    22.         this.quarterCount = quarterCount;
    23.         this.oneDollarCount = oneDollarCount;
    24.         this.fiveDollarCount = fiveDollarCount;
    25.         this.twentyDollarCount = twentyDollarCount;
    26.     }
    28.     public static Money add(Money money1, Money money2) {
    29.         return new Money(
    30.                 money1.oneCentCount + money2.oneCentCount,
    31.                 money1.tenCentCount + money2.tenCentCount,
    32.                 money1.quarterCount + money2.quarterCount,
    33.                 money1.oneDollarCount + money2.oneDollarCount,
    34.                 money1.fiveDollarCount + money2.fiveDollarCount,
    35.                 money1.twentyDollarCount + money2.twentyDollarCount);
    36.     }
    38.     @Override
    39.     protected boolean equalsCore(Money other) {
    40.         return oneCentCount == other.oneCentCount
    41.                 && tenCentCount == other.tenCentCount
    42.                 && quarterCount == other.quarterCount
    43.                 && oneDollarCount == other.oneDollarCount
    44.                 && fiveDollarCount == other.fiveDollarCount
    45.                 && twentyDollarCount == other.twentyDollarCount;
    46.     }
    48.     @Override
    49.     protected int getHashCodeCore() {
    50.         int hashCode = oneCentCount;
    51.         hashCode = (hashCode * 397) ^ tenCentCount;
    52.         hashCode = (hashCode * 397) ^ quarterCount;
    53.         hashCode = (hashCode * 397) ^ oneDollarCount;
    54.         hashCode = (hashCode * 397) ^ fiveDollarCount;
    55.         hashCode = (hashCode * 397) ^ twentyDollarCount;
    56.         return hashCode;
    57.     }
    58. }

    父类的抽象方法equalsCore，getHashCodeCore子类是必须实现的。equalsCore根据每个字段的值来判断两个值对象是否相等。
    image.png
    在这里，我再次重申实体和值对象的区别：实体ID相等而值对象结构相等，值对象不存在ID字段。