Question

我正在研究Java的通用ValueObject类的可能实现。我看到了多种可能的解决方案 - 硬编码等于每个对象中的方法，使用Lombok，使用来自Google的@AutoValue，使用反射等。只记得使用lambdas是一种可能的解决方案 - 但不知道这是否有任何缺点一个？

import java.util.List;
import java.util.Objects;
import java.util.function.Supplier;

public abstract class ValueObject<T extends ValueObject<T>> {
    protected abstract List<Supplier> supplyGettersToIncludeInEqualityCheck();

    @Override
    public int hashCode() {
        return super.hashCode();
    }

    @Override
    public boolean equals(Object obj) {

        T obj2 = (T)obj;

        for(int i = 0; i< supplyGettersToIncludeInEqualityCheck().size(); i++){
            if(!Objects.equals(supplyGettersToIncludeInEqualityCheck().get(i).get(), obj2.supplyGettersToIncludeInEqualityCheck().get(i).get())){
                return false;
            }
        }

        return true;
    }
}

然后在值对象中使用标准用法就像

import java.util.*;
import java.util.function.Supplier;

public class ValO extends ValueObject<ValO> {
    private String value;
    private int int2;

    public ValO(String value, int int2) {
        this.value = value;
        this.int2 = int2;
    }

    public String getValue() {
        return value;
    }

    public int getInt2() {
        return int2;
    }

    @Override
    protected List<Supplier> supplyGettersToIncludeInEqualityCheck() {
        return Arrays.asList(this::getValue, this::getInt2);
    }
}

这个ValueObject Java实现的任何缺点

0 个答案: