用java设计一个灵活的密钥类

我正试图用java设计一个通用密钥类来表示主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 ;
}
}

@SuppressWarnings（“串行”）
@GWT兼容
公共类密钥实现可序列化{
公共枚举密钥类型{
BigInt，Uuid，String；
}
私有最终密钥值；
私有最终密钥类型KeyType；
键（）{
keyValue=null；
keyType=null；
}
公钥（T值）{
this.keyValue=值；
this.keyType=determineKeyType（值）；
}
/**
*@返回
*/
私钥类型determineKeyType（对象值）{
if（isValueUuid（值））
返回KeyType.Uuid；
else if（BigInteger的值实例）
返回KeyType.BigInt；
其他的
返回KeyType.String；
}
/**
*@param值
*@返回
*/
私有布尔值isValueUuid（对象值）{
//TODO自动生成的方法存根
返回false；
}
公钥（T val，密钥类型tp）{
this.keyValue=val；
this.keyType=tp；
}
公钥类型getKeyType（）{
返回键类型；
}
@凌驾
公共布尔等于（对象obj）{
返回super.equals（obj）；
}
公共T getKeyValue（）{
返回此.keyValue；
}
}

在我看来，您将从这里的成功中获益

您将拥有一个接口

Key

，一个

AbstractKey

，以及您想要的这个

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);
    }
}

公共接口密钥扩展可序列化{
T getKeyValue（）；
}
公共抽象类AbstractKey实现了{
@凌驾
公共布尔等于（对象obj）{
if（obj==null）{
返回false；
}
if（AbstractKey的obj实例）{
返回getKeyValue（）.equals（（（AbstractKey）obj.getKeyValue（））；
}
返回false；
}
}
公共类StringKey扩展了AbstractKey{
私有字符串键值；
StringKey（）{
超级（）；
}
受保护的StringKey（字符串值）{
超级（val）；
this.keyValue=val；
}
@凌驾
公共字符串getKeyValue（）{
返回键值；
}
}
公共类BigIntKey扩展了AbstractKey{
私有BigInteger键值；
BigIntKey（）{
超级（）；
}
受保护的BigIntKey（BigInteger val）{
超级（val）；
this.keyValue=val；
}
@凌驾
public BigInteger getKeyValue（）{
返回键值；
}
}
...
公共类钥匙工厂{
公共静态密钥getKey（字符串obj）{
返回新的StringKey（obj）；
}
公共静态密钥getKey（BigInteger obj）{
返回新的BigIntKey（obj）；
}
}

---

此解决方案的一个优点是，即使它比您已有的解决方案更详细，也可以将

键的类型限制为实际需要的类型。此外，对于可见性有限的构造函数（仅足以使GWT正确编译），您可以强制代码使用
KeyFactory
不确定其余部分，但您的
equals
委托给
对象的
equals
，该对象基于身份。这是你想要的吗？这似乎不是因为您想检查各种类型的密钥。

另外，如果您覆盖
equals
，那么您必须覆盖
hashCode
是否有一个现有的GWT兼容实现可以执行类似的操作？在这种情况下适用的最佳实践是什么？注意-一些方法还没有实现。如果我们想要避免工厂和使用guice注入，你知道会是什么样子吗？通过使用guice提供程序/绑定，我们可以获得相同的结果吗？从我的需求角度来看，这里有一个问题。当我收到一个密钥引用但我不知道其类型时会发生什么？i、 我无法确定里面钥匙的类型。您建议我们如何克服这个问题？您可以在
Key
接口
getType（）
中使用另一个方法，实现类将以这种方式实现它：
Class getType（）{return keyValue.getClass（）；}