初始化vba库65535出错_枚举超出静态初始化的65535字节限制...最好做什么？

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?

解决方案

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

@Enumerated(STRING)

private DescriptorEnum descriptor;

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:

public final class Descriptor {

public final String acronym;

private static final Hashtable all = new Hashtable();

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;

}

}

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:

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

}

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.