Question

我们有两种ID，内部和外部A.当前记录同时具有内部和外部ID，并且将来可能存在externalB类型的ID，因此某些记录可能具有内部和外部B ID。

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

我们如何防止此类错误？将String键包装到InternalID，ExternalAID，ExternalBID类并使用那些包装器到处工作吗？我担心内存占用，如果我们谈论数以亿计的密钥，或者其他可能出错的东西，这种情况尤其会发生。

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

如果所有密钥都采用不同的鉴别器，您也可以从Key密钥创建自己的String类。

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

换行字符串键以区分外键和内键

1 个答案: