0

我正在尝试在 java 中设计一个通用的 Key 类来表示主 pojo 键。

这些值可以是各种类型，例如 BigInteger、String、Uuid。我正在寻找实现这样一个类的最佳选择。我当前的实现看起来像这样。

任何人都可以帮助我进行更准确的实施或确定当前实施的问题吗？我还没有实现 equals 方法。欢迎任何指点。

此类需要与 GWT 兼容。

@SuppressWarnings("serial")
@GwtCompatible
public class Key<T extends Serializable> implements Serializable {

public enum KeyType {
    BigInt, Uuid, String ;

}

private final T keyValue  ;
private final KeyType keyType  ;

Key() {
    keyValue = null;
    keyType = null;
}

public Key(T value){
    this.keyValue =  value ;
    this.keyType = determineKeyType(value);
}

/**
 * @return
 */
private KeyType determineKeyType(Object value) {

    if ( isValueUuid(value))
        return KeyType.Uuid ;

    else if (value instanceof BigInteger)
        return KeyType.BigInt ;

    else 
        return KeyType.String; 
}

/**
 * @param value
 * @return
 */
private boolean isValueUuid(Object value) {
    // TODO Auto-generated method stub
    return false;
}

public Key(T val, KeyType tp){
    this.keyValue = val ;
    this.keyType = tp;
}

public KeyType getKeyType(){
    return keyType ;
}


@Override
public boolean equals(Object obj) {
    return super.equals(obj);
}

public T getKeyValue(){
    return this.keyValue ;
}
}
4

2 回答 2

1

在我看来，您将从这里的工厂模式中受益。

您将拥有一个 interface Key、 anAbstractKey以及任意数量的实现AbstractKey（在您的示例中，它应该是 3 个）。KeyFactory 将负责创建密钥。

实际上，它会给出：

public interface Key<T> extends Serializable {
    T getKeyValue();
}

public abstract class AbstractKey<T> implements Key<T> {

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (obj instanceof AbstractKey) {
            return getKeyValue().equals(((AbstractKey) obj).getKeyValue());
        }
        return false;
    }
}

public class StringKey extends AbstractKey<String> {

    private String keyValue;

    StringKey() {
        super();
    }

    protected StringKey(String val) {
        super(val);
        this.keyValue = val;
    }

    @Override
    public String getKeyValue() {
        return keyValue;
    }
}

public class BigIntKey extends AbstractKey<BigInteger> {

    private BigInteger keyValue;

    BigIntKey() {
        super();
    }

    protected BigIntKey(BigInteger val) {
        super(val);
        this.keyValue = val;
    }

    @Override
    public BigInteger getKeyValue() {
        return keyValue;
    }
}

...

public class KeyFactory {
    public static Key<String> getKey(String obj) {
        return new StringKey(obj);
    }

    public static Key<BigInteger> getKey(BigInteger obj) {
        return new BigIntKey(obj);
    }
}

此解决方案的一个优点是，即使它比您已有的更详细，您也可以将Keys 的类型限制为您实际需要的类型。此外，对于可见性有限的构造函数（刚好足以使 GWT 正确编译），您可以强制代码使用KeyFactory.

于 2012-09-02T08:28:52.767 回答
0

不确定其余的，但你的equals代表equals是Object基于身份的。这是你想要的吗？似乎不是因为您想检查可能是各种类型的键。
此外，如果您覆盖equals，那么您必须覆盖hashCode

于 2012-09-02T13:19:52.827 回答