Enum überschreitung der 65535 Byte-Grenzwert der statischen Initialisierer,... was am besten zu tun ist?

Einfach. Verwenden Sie nicht enum für diese. Das können Sie nicht. Es wird nicht funktionieren.

Sind die Chancen, dass Ihr Quellcode nicht explizit Bezug auf viele der enum-Werte. Vielmehr sind Sie mit dem enum als ein bequemer Weg, um die Zuordnung zwischen Objekt-Instanzen und string als Namen. So ersetzen Sie einfach den enum-Typ mit einem Typ, der explizit verwaltet die Zuordnung initialisieren durch das Lesen aus einer Datei oder Datenbank. Wenn Sie es richtig machen, erhalten Sie die rechnerische Eigenschaften und Typ-Sicherheit von enum. Das einzige, was Sie verlieren, ist der syntaktische Zucker ... und der Statik.

Dieser Ansatz hätte den zusätzlichen Vorteil, dass Sie ändern können, die "Deskriptoren" mapping ohne änderungen am Quellcode des Programms.

Durch die Art und Weise, die Begrenzung, Sie laufen in die von der JVM-class-file-format. Eine Methode oder ein Konstruktor hat eine Obere Größenbeschränkung von 2^16 bytes, und ein Klassen statische Initialisierungs-code wird dargestellt als eine spezielle Methode mit einer funky Namen.

UPDATE

Leider Ihr selbst beantworten, die Lösung wird immer noch laufen in ein anderes 64K-limit ... wenn geschoben zu weit. Die Aufteilung der initialize() - Methode wird um die Methode size limit, aber es gibt auch eine 64 Kb-limit auf die Anzahl der Einträge in den a-Klassen Konstanten-pool. Jedes String-literal erfordert ein Konstanten-pool-Eintrag.

Können Sie versuchen, die typesafe enum pattern
beschrieben von Joshua Bloch in der ersten Ausgabe von seinem Buch "Effective Java".

Die Idee ist, erstellen Sie eine Klasse mit einem privaten Konstruktor. Innerhalb dieser Klasse definieren Sie statische Instanzen von jeder Zahl, die Sie möchten-genau wie im Java-enum.

Ich weiß nicht, ob es ein limit für die Anzahl der statischen Elemente in der Java-Sprache, obwohl.

Meine ursprüngliche Idee war die Karte die Enum mit der @Enumerated Kommentar. Dies würde ausgesehen haben, wie im folgenden Beispiel:

@Enumerated(STRING)
private DescriptorEnum descriptor;

Würde die Datenbank eine Spalte " DESKRIPTOR-Typ varchar und im Ruhezustand (in meinem Fall) würde die Karte die Zeichenfolge in die Aufzählung.

Aber ich habe das limit von 65k (siehe Frage), das ist zu klein in meinem Fall. Aber ich habe eine Lösung gefunden. Haben Sie einen Blick auf das folgende Beispiel:

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

Diesem Deskriptor-Klasse simuliert die Verwendung eines typischen enum. Aber jetzt bin ich in der Lage, teilen Sie die initialize () - Methode in mehrere diejenigen, die arbeiten rund um die 65k Grenze, besteht auch für Methoden. Die Enum nicht erlauben, teilen Sie die Initialisierung in mehrere Stücke - meiner Klasse.

Nun, ich habe mit einer etwas anderen Zuordnung jedoch:

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

Diese Weise kann ich die Klasse verwenden, wie ein Enum in den meisten Fällen. Es ist ein bisschen schwierig... aber es scheint zu funktionieren. Vielen Dank für all den input, die schließlich führte mich zu dieser Lösung.