blocks|key|312189|text|您可以尝试Joshua+Bloch在他的书“edition+typesafe+enum+pattern+”的第一版中描述的Java。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|312190|这个想法是创建一个具有私有构造函数的类。在这个类中，您可以定义任意数量的静态实例-就像在Java枚举中一样。|312191|不过，我不知道Java语言中的静态成员数量是否有限制。|312192|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/developer/Books/shiftintojava/page1.html#replaceenums^0|U|M|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

You can try the <a href="http://java.sun.com/developer/Books/shiftintojava/page1.html#replaceenums" rel="nofollow noreferrer">typesafe enum pattern
</a> described by Joshua Bloch in the first edition of his book "Effective Java".

The idea is to create a class with a private constructor. Inside this class you define static instances of any number you want to-just as in a Java enum.

I don't know if there is a limit for the number of static members in the Java language, though.

blocks|key|3053447|text|很简单。请不要使用enum完成此操作。你不能，它不会起作用的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3053448|您的源代码可能没有显式引用许多枚举值。相反，使用枚举可以方便地在唯一对象实例和字符串名称之间进行映射。因此，只需将枚举类型替换为显式管理映射的类型，通过从文件或数据库读取来初始化它。如果操作得当，您将获得枚举的计算属性和类型安全性。你唯一失去的就是语法糖..。还有静力学。|3053449|这种方法有一个额外的优点，那就是你可以修改“描述符”映射，而不需要修改程序的源代码。|3053450|3053451|顺便说一句，您遇到的限制是由JVM类文件格式施加的。方法或构造函数的大小上限为2%5E16字节，类的静态初始化代码被表示为一个带有时髦名称的特殊方法。|3053452|更新|BOLD|3053453|不幸的是，您的自助解决方案仍然会遇到不同的64K限制……如果太过分的话。拆分initialize()方法可以绕过方法大小限制，但类常量池中的条目数量也有64K的限制。每个字符串字面值都需要一个常量池项。|3053454|entityMap^0|9|4|0|0|0|0|0|0|2|0|12|C|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|Z|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|10|8|@$9|11|A|12|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|S|$]]

Simple. Don't use <code>enum</code> for this. You can't. It won't work.

The chances are that your source code does not explicitly refer to many of the enum values. Rather, you are using the enum as a convenient way to map between unique object instances and string names. So just replace the enum type with a type that explicitly manages the mapping, initializing it by reading from a file or database. If you do it right, you will get the computational properties and type-safety of an enum. The only thing you lose is the syntactic sugar ... and the statics.

This approach will have the added advantage that you can modify the 'descriptors' mapping without modifying the source code of your program.

<hr>

By the way, the limitation you are running into is imposed by the JVM class file format. A method or constructor has an upper size limit of 2^16 bytes, and a classes static initialization code is represented as a special method with a funky name.

UPDATE

Unfortunately your self-answer solution will still run into a different 64K limit ... if pushed too far. Splitting the <code>initialize()</code> method gets around the method size limit, but there is also a 64K limit on the number of entries in a classes constant pool. Each String literal requires a constant pool entry.

blocks|key|3053501|text|这不是一个简单的解决方案，但您可以尝试...修补Java编译器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3053502|当您编写enum时，Java编译器会生成一个扩展java.lang.Enum的类(如果有特定于常量的方法，可能会有几个类)。该类有一些(隐藏的)静态字段，这些字段在字节码级别上是用特殊的<clinit>()方法初始化的(第一次使用该类时，JVM会调用这个方法)。与任何其他方法一样，<clinit>()方法的代码限制为65535字节。在<clinit>()字节码中，每个常量贡献了大约20到22个字节(如果有特定于常量的构造函数，则会更多)，因此达到了大约3000个枚举常量的限制。|offset|length|style|CODE|3053503|现在，<clinit>()方法有了一个有趣的名字，但它并没有什么特别之处；它可以调用其他方法。Java编译器可以将庞大的<clinit>()分成几个隐藏子方法，然后<clinit>()将一个接一个地调用这些子方法。Java编译器目前还没有做到这一点，但理论上它可以做到这一点。任何JRE都可以处理结果。|3053504|或者，综合您的enum类，从专用程序生成字节码，该程序本身可能用Java编写。本质上，这就像是为特定的目标编写自己的专用编译器，并使用自己的源码语法。BCEL库可能会有所帮助。|3053505|请注意，还有其他限制可能会跳到您身上。对于每个枚举常量，静态代码(<clinit>()中的那个)使用两个“常量”，这两个“常量”是聚集在已编译类的“常量池”部分的内部值。这两个值是常量名称(以字符串形式)和结果静态字段引用。对65536个常量池条目有硬限制(索引为16位)，因此不超过32000个枚举常量。打了补丁的Java编译器可以通过生成几个隐藏类来绕过这一限制，每个隐藏类都有自己的常量池。一个更严格的限制是静态字段的数量:每个枚举常量都成为"enum“类中的一个静态字段，并且一个类中的字段不能超过65535个(静态的或非静态的)。|3053506|entityMap|0|LINK|mutability|MUTABLE|url|http://jakarta.apache.org/bcel/^0|0|4|4|O|E|2L|A|3X|A|4O|A|0|3|A|1O|A|2A|A|0|23|4|0|0|X|A|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@$D|X|E|Y|F|G]|$D|Z|E|10|F|G]|$D|11|E|12|F|G]|$D|13|E|14|F|G]|$D|15|E|16|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|17|8|@$D|18|E|19|F|G]|$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1E|8|@]|9|@$D|1F|E|1G|1|1H]]|A|$]]|$1|L|3|M|5|6|7|1I|8|@$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]]]

This is not a simple solution, but you may try to... patch the Java compiler.

When you write an <code>enum</code>, the Java compiler generate a class which extends <code>java.lang.Enum</code> (possibly several classes, if there are constant-specific methods). The class has some (hidden) static fields, which, at the bytecode level, are initialized with the special <code>&lt;clinit&gt;()</code> method (which the JVM calls when the class is first used). As any other method, the code for the <code>&lt;clinit&gt;()</code> method is limited to 65535 bytes. Each constant contributes to about 20 to 22 bytes in the <code>&lt;clinit&gt;()</code> bytecode (more if there are constant-specific constructors), so you hit the limit at about 3000 enumeration constants.

Now the <code>&lt;clinit&gt;()</code> method has a funny name but it is nothing really special; it can invoke other methods. The Java compiler could split the mammoth <code>&lt;clinit&gt;()</code> into several hidden sub-methods which <code>&lt;clinit&gt;()</code> would then invoke one after the other. The Java compiler does not currently do that, but it theoretically could. The result would be processable by any JRE.

Alternatively, synthesize your enum class synthetically, generating bytecode from a dedicated program, possibly itself written in Java. In essence, this is like writing your own specialized compiler, for a specific target and using your own source syntax. The <a href="http://jakarta.apache.org/bcel/" rel="noreferrer">BCEL</a> library may help. 

Note that there are other limits which could jump on you. For each enumeration constant, the static code (the one in <code>&lt;clinit&gt;()</code>) uses two "constants", which are internal values aggregated in the "constant pool" part of the compiled class. The two values are the constant name (as a string) and the resulting static field reference. There is a hard limit on 65536 constant pool entries (indexes are on 16 bits), so no more than a bit more than 32000 enumeration constants. A patched Java compiler could walk around that limit by generating several hidden classes, each with its own constant pool. A harder limit is in the number of static fields: each enumeration constant becomes a static field in the "enum" class, and there can be no more than 65535 fields (static or not) in a class.

blocks|key|315224|text|您可以尝试在顶级类中嵌套静态内部类|type|unstyled|depth|inlineStyleRanges|entityRanges|data|315225|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You might try nesting static inner-classes within a top-level class

blocks|key|3267066|text|我最初的想法是使用@Enumerated注解来映射Enum。这看起来像下面的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3267067|@Enumerated(STRING)
private+DescriptorEnum+descriptor;|code-block|syntax|javascript|3267068|数据库将有一个名为DESCRIPTOR的列，类型为varchar，Hibernate+(在我的示例中)将字符串映射到枚举。|3267069|但我有65k的限制(见问题)，这在我的情况下是很小的。但我找到了一个解决方案。看一下下面的例子：|3267070|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:+"+%2B+this.acronym);
++++++++}
++++++++all.put(this.acronym,+this);
++++}
++++public+static+Descriptor+valueOf(String+acronym)+{
++++++++return+all.get(acronym);
++++}
++++public+String+value()+{
++++++++return+this.acronym;
++++}
}|3267071|这个描述符类模拟典型枚举的用法。但现在我可以将initialize()方法拆分成几个方法，以绕过同样存在于方法的65k限制。Enum不允许将初始化分成几个块-我的类就是这么做的。|3267072|现在我必须使用一个稍微不同的映射：|3267073|@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;
}|3267074|这样，在大多数情况下，我可以像使用Enum一样使用该类。有点棘手..。但它似乎起作用了。感谢您的所有投入，最终使我找到了那个解决方案。|3267075|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

My original idea was to map the Enum using the @Enumerated annotion. This would have looked like the following example:

<pre><code>@Enumerated(STRING)
private DescriptorEnum descriptor;
</code></pre>

The database would have a column called DESCRIPTOR of type varchar and Hibernate (in my case) would map the string to the enumeration.

But I have that limit of 65k (see question) which is to small in my case. But I've found a solution. Have a look at the following example:

<pre><code>public final class Descriptor {
 public final String acronym;
 private static final Hashtable&lt;String, Descriptor&gt; all = new Hashtable&lt;String, Descriptor&gt;();
 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;
 }
}
</code></pre>

This Descriptor class simulates the usage of a typical enum. But now I'm able to split the initialize() method into several ones that work around the 65k limit that also exists for methods. The Enum doesn't allow to split the initialization into several chunks - my class does.

Now I have to use a slightly different mapping though:

<pre><code>@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;
}
</code></pre>

This way I can use the class like an Enum in most cases. It's a bit tricky... but it seems to work. Thanks for all the input that finally led me to that solution.

I've started a rather large Enum of so called Descriptors that I've wanted to use as a reference list in my model. But now I've come across a compiler/VM limit the first time and so I'm looking for the best solution to handle this.

Here is my error : The code for the static initializer is exceeding the 65535 bytes limit

It is clear where this comes from - my Enum simply has far to much elements. But I need those elements - there is no way to reduce that set.

Initialy I've planed to use a single Enum because I want to make sure that all elements within the Enum are unique. It is used in a Hibernate persistence context where the reference to the Enum is stored as String value in the database. So this must be unique!

The content of my Enum can be devided into several groups of elements belonging together. But splitting the Enum would remove the unique safety I get during compile time. Or can this be achieved with multiple Enums in some way?

My only current idea is to define some Interface called Descriptor and code several Enums implementing it. This way I hope to be able to use the Hibernate Enum mapping as if it were a single Enum. But I'm not even sure if this will work. And I loose unique safety.

Any ideas how to handle that case?

Enum exeeding the 65535 bytes limit of static initializer... what's best to do?

数据库

编译器

Java

我已经开始了一个相当大的名为Descriptors的枚举，我想在我的模型中将其用作一个引用列表。但是现在我第一次遇到了编译器/VM的限制，所以我正在寻找最好的解决方案来处理这个问题。下面是我的错误:静态初始化器的代码超过了65535字节的限制很清楚这是从哪里来的-我的枚举只是有很多元素。但我需要这些元素--没有办法减少...

问枚举超出静态初始值设定项的65535字节限制...最好的办法是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问枚举超出静态初始值设定项的65535字节限制...最好的办法是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问枚举超出静态初始值设定项的65535字节限制...最好的办法是什么？
EN