Question

I am trying to design a generic Key class in java to represent primary pojo keys.

The values can be of various types i.e. BigInteger, String, Uuid’s . I am looking for best option to implement such a class. My current implementation looks something like this.

Can anyone help me with a more accurate implementation or identify issues with the current implementation? I am yet to implement a equals method. Any pointers are welcome.

This class needs to be GWT compatible.

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

Answer 1

It looks to me me that you would benefit from a Factory pattern here.

You would have an interface Key, an AbstractKey, and as many implementations of this AbstractKey as you want (in your example case, it should be 3). The KeyFactory would be in charge of creating the key.

Practically, it would give:

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

One advantage of this solution, even if it’s more verbose than the one you already have, is that you can restrict the types of your Keys to what you actually need. In addition, with constructors that have limited visibility (just enough to make GWT compile properly), you can enforce the code to use the KeyFactory.