java - 包装字符串键以区分外部键和内部键

Question

我们有两种 ID，internal 和 externalA。当前记录同时具有内部和外部 A ID，将来可能会有外部 B 类型的 ID，因此某些记录可能具有内部和外部 B ID。

我们目前将所有 ID 表示为字符串。它可能会导致错误，其中方法需要内部 key ，但实际上传递了外部 key 。

我们如何防止此类错误？将字符串键包装到 InternalID、ExternalAID、ExternalBID 类中并在任何地方使用这些包装器对我们有用吗？我担心内存占用，如果我们谈论的是数亿个 key ，这可能尤其会发生，而且可能还有其他可能出错的东西。

Answer 1

我认为您需要一个用于所有字符串键的鉴别器。例如:

String internalKey= "I1000201";
String externalAKey= "A1000201";
String externalBKey= "B1000201";

然后您可以通过第一个字符检查实际键类型来防止错误，例如:

char type =  key.charAt(0);
if(type != 'I') throw new IllegalArgumentException("Invalid key");
// go on

如果所有键都采用不同的鉴别符，您还可以从 String 键创建自己的 Key 类。

Key internal = Key.from("I1000201"); //internal key
Key external = Key.from("A1000201"); //external key A
Key.from("X1000201"); 
//        ^--- throws IllegalArgumentException for invalid key type

---

public class Key {
    private final String key;
    private final Visibility visibility;

    private static final BitSet externals = new BitSet();

    static {
        // register your own external key here
        externals.set('A');
        externals.set('B');
    }

    //      v--- make the Key constructor private.
    private Key(String key, Visibility visibility) {
        this.key = key;
        this.visibility = visibility;
    }


    public static Key from(String key) {
        return new Key(key, visibilityOf(key));
    }

    private static Visibility visibilityOf(String key) {
        char type = key.charAt(0);
        return type == 'I' ? Visibility.INTERNAL
                           : externals.get(type) ? Visibility.EXTERNAL
                                                 : failsOnInvalidKey(key);
    }

    private static Visibility failsOnInvalidKey(String key) {
        throw new IllegalArgumentException("Invalid Key: \"" + key + "\"");
    }

    public char type() {
        return key.charAt(0);
    }

    public String value() {
        return key.substring(1);
    }

    public boolean isExternal() {
        return visibility == Visibility.EXTERNAL;
    }

    public String toString() {
        return key;
    }

    // preserve it maybe will introduce additional behavior in future
    private enum Visibility {
        EXTERNAL,
        INTERNAL
    }
}