0

プライマリpojoキーを表すJavaで汎用Keyクラスを設計しようとしています。

値は、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

ここでファクトリパターンの恩恵を受けると私には思えます。

インターフェイス、、、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);
    }
}

このソリューションの利点の1つは、すでに持っているものよりも冗長であっても、Key実際に必要なものにタイプを制限できることです。さらに、可視性が制限されている（GWTを適切にコンパイルするのに十分な）コンストラクターを使用すると、を使用するようにコードを強制できますKeyFactory。

于 2012-09-02T08:28:52.767 に答える
0

残りについてはわかりませんが、そのequals代表者equalsはObjectIDベースです。これは、あなたの望むことですか？さまざまなタイプのキーをチェックしたいので、そうではないようです。
また、オーバーライドする場合は、オーバーライドするequals必要がありますhashCode

于 2012-09-02T13:19:52.827 に答える