枚举超出静态初始化程序的 65535 字节限制...最好做什么？

Question

我已经开始了一个相当大的所谓的描述符枚举，我想将其用作模型中的参考列表。但现在我第一次遇到了编译器/虚拟机限制，所以我正在寻找最好的解决方案来处理这个问题。

这是我的错误：静态初始化程序的代码超出了 65535 字节限制

很明显这是从哪里来的 - 我的 Enum 只是包含太多元素。但我需要这些元素 - 无法减少该集合。

最初，我计划使用单个枚举，因为我想确保枚举中的所有元素都是唯一的。它用在 Hibernate 持久化上下文中，其中对 Enum 的引用作为字符串值存储在数据库中。所以这一定是独一无二的！

我的枚举的内容可以分为属于在一起的几组元素。但是拆分枚举会消除我在编译时获得的独特安全性。或者可以通过某种方式使用多个枚举来实现这一点吗？

我当前唯一的想法是定义一些名为 Descriptor 的接口，并编写几个实现它的枚举。这样我希望能够像使用单个 Enum 一样使用 Hibernate Enum 映射。但我什至不确定这是否有效。我失去了独特的安全感。

有什么想法如何处理这种情况吗？

Answer 1

简单的。不要为此使用enum。你不能。这是行不通的。

您的源代码很可能没有明确引用许多枚举值。相反，您使用枚举作为在唯一对象实例和字符串名称之间映射的便捷方法。因此，只需将枚举类型替换为显式管理映射的类型，通过从文件或数据库读取来初始化它。如果你做得正确，你将获得枚举的计算属性和类型安全性。你唯一失去的是语法糖……和静态。

这种方法还有一个额外的优点，即您可以修改“描述符”映射，而无需修改程序的源代码。

---

顺便说一句，您遇到的限制是由 JVM 类文件格式造成的。方法或构造函数的大小上限为 2^16 字节，类静态初始化代码表示为具有时髦名称的特殊方法。

更新

不幸的是，如果推得太远，您的自助解答解决方案仍将遇到不同的 64K 限制。拆分 initialize() 方法可以绕过方法大小限制，但类常量池中的条目数量也有 64K 的限制。每个字符串文字都需要一个常量池条目。

Answer 2

这不是一个简单的解决方案，但您可以尝试...修补 Java 编译器。

当您编写enum时，Java编译器会生成一个扩展java.lang.Enum的类（如果有特定于常量的方法，可能是多个类）。该类具有一些（隐藏）静态字段，这些字段在字节码级别上使用特殊的 () 方法（首次使用该类时 JVM 调用该方法）进行初始化。与任何其他方法一样，() 方法的代码限制为 65535 字节。每个常量在 () 字节码中贡献大约 20 到 22 个字节（如果存在特定于常量的构造函数，则更多），因此您达到了大约 3000 个枚举常量的限制。

现在，() 方法有一个有趣的名称，但它并没有什么特别之处；它可以调用其他方法。 Java 编译器可以将庞大的 () 拆分为几个隐藏的子方法，然后 () 会调用这些子方法一个接一个。 Java 编译器目前无法做到这一点，但理论上可以。结果可由任何 JRE 处理。

或者，综合地综合您的枚举类，从专用程序生成字节码，该程序本身可能是用 Java 编写的。本质上，这就像为特定目标编写您自己的专用编译器并使用您自己的源语法。 BCEL 库可能会有所帮助。

请注意，还有其他限制可能会给您带来麻烦。对于每个枚举常量，静态代码（() 中的代码）使用两个“常量”，它们是聚合在编译类的“常量池”部分中的内部值。这两个值是常量名称（作为字符串）和生成的静态字段引用。常量池条目有 65536 个硬限制（索引为 16 位），因此枚举常量最多不超过 32000 个。经过修补的 Java 编译器可以通过生成多个隐藏类来绕过该限制，每个隐藏类都有自己的常量池。更严格的限制是静态字段的数量：每个枚举常量都成为“enum”类中的静态字段，并且一个类中的字段（静态或非静态）不能超过 65535 个。

Answer 3

您可以尝试 类型安全枚举模式
由 Joshua Bloch 在他的书《Effective Java》第一版中描述。

这个想法是创建一个带有私有构造函数的类。在此类中，您可以定义任意数量的静态实例，就像在 Java 枚举中一样。

不过，我不知道 Java 语言中静态成员的数量是否有限制。

Answer 4

您可以尝试在顶级类中嵌套静态内部类

Answer 5

我最初的想法是使用 @Enumerated 注释来映射 Enum。这看起来像下面的示例：

@Enumerated(STRING)
private DescriptorEnum descriptor;

数据库将有一个名为 DESCRIPTOR 的 varchar 类型列，Hibernate（在我的例子中）会将字符串映射到枚举。

但我有 65k 的限制（参见问题），这对我来说太小了。但我找到了解决方案。看一下下面的示例：

public final class Descriptor {
    public final String acronym;
    private static final Hashtable<String, Descriptor> all = new Hashtable<String, Descriptor>();
    static {
        initialize();
    }
    private static void initialize() {
        new Descriptor("example001");
        new Descriptor("example002");
        new Descriptor("example003");
    }
    private Descriptor(String acronym) {
        this.acronym = acronym;
        if (all.contains(this.acronym)) {
            throw new RuntimeException("duplicate acronym: " + this.acronym);
        }
        all.put(this.acronym, this);
    }
    public static Descriptor valueOf(String acronym) {
        return all.get(acronym);
    }
    public String value() {
        return this.acronym;
    }
}

这个 Descriptor 类模拟了典型枚举的用法。但现在我可以将initialize() 方法拆分为多个方法，以解决方法也存在的65k 限制。枚举不允许将初始化分成几个块 - 我的类允许。

现在我必须使用稍微不同的映射：

@Column(name = "DESCRIPTOR")
private String                  descriptorAcronym       = null;
private transient Descriptor    descriptor              = null;
public Descriptor getDescriptor() {
    return descriptor;
}
public void setDescriptor(Descriptor desc) {
    this.descriptor = desc;
    this.descriptorAcronym = desc != null ? desc.acronym : null;
}
public String getDescriptorAcronym() {
    return descriptorAcronym;
}
public void setDescriptorAcronym(String desc) {
    this.descriptorAcronym = desc;
    this.descriptor = desc != null ? Descriptor.valueOf(desc) : null;
}
@PostLoad
private void syncDescriptor() {
    this.descriptor = this.descriptorAcronym != null ? Descriptor.valueOf(this.descriptorAcronym) : null;
}

这样在大多数情况下我可以像枚举一样使用该类。这有点棘手......但似乎有效。感谢您的所有意见，最终使我找到了该解决方案。