Jak obejść limit rozmiaru statycznym initialiser w Javie przy inicjalizacji duże ilości stałych

Question

Mam klasy gospodarstwa dużą wierzchowca generowanych stałych jako takie:

public class Constants extends SomeBaseClass { 

    // init() is defined in some base class... 
    public static final XXX KEY1 = init(...); 
    public static final XXX KEY2 = init(...); 
    public static final XXX KEY3 = init(...); 

    // ... 
    public static final XXX KEY2000 = init(...); 
} 

Gdy liczba generowanych stałych jest bardzo wysoka, powoduje to statyczny inicjator, który jest większy niż górny limit dla metod Java (tj.> 64kb), powodując błąd kompilatora. Jednym rozwiązaniem jest utworzenie kilku „metody inicjalizacji bloków” dla bloków, które może być zagwarantowane, aby wytworzyć mniej niż 64kb bajtu kodu, tak, że pasują do metody:

public class Constants extends SomeBaseClass { 

    public static XXX KEY1; 
    public static XXX KEY2; 
    public static XXX KEY3; 

    // ... 
    public static XXX KEY2000; 

    static { 
    initialise0001To1000(); 
    initialise1001To2000(); 
    } 

    private static void initialise0001To1000() { 
    KEY1 = init(...); 
    KEY2 = init(...); 
    KEY3 = init(...); 
    // ... 
    } 

    private static void initialise1001To2000() { 
    // ... 
    KEY2000 = init(...); 
    } 
} 

Wadą jest to, że mogę nie deklarujemy już stałych jako final, ponieważ nie są one już inicjalizowane bezpośrednio w statycznym inicjatorze.

Moje pytanie brzmi: jak mogę ominąć to ograniczenie kompilatora/maszyny JVM w sposób, w jaki nadal mogę generować stałe static final?

Answer 1

W końcu zdecydowałem się na rozwiązanie obejmujące klasy zagnieżdżone. To zostało zasugerowane w komentarzu do this answer here przez użytkownika Loadmaster.Klasy zagnieżdżone mają dwie zalety:

• Pozwalają na ukrywanie te szczegóły implementacji obejście od świata zewnętrznego poprzez bycie private klas zagnieżdżonych
• Pozwalają one na utrzymywanie stałych final

Ale mają też wadę w porównaniu do templatetypedef's rozwiązania:

• będę napotkasz ten sam problem znowu z dużo lar numery ger stałych

Teraz jednak wydaje się być najbardziej odpowiednie rozwiązanie:

public class Constants { 

    public static XXX KEY1 = Constants1.KEY1; 
    public static XXX KEY2 = Constants1.KEY2; 
    public static XXX KEY3 = Constants1.KEY3; 

    // ... 
    public static XXX KEY2000 = Constants2.KEY2000; 

    // Nested class holding 1000 constants 
    private static class Constants1 extends SomeBaseClass { 
    KEY1 = init(...); 
    KEY2 = init(...); 
    KEY3 = init(...); 
    // ... 
    } 

    // Nested class holding the next 1000 constants 
    private static class Constants2 extends SomeBaseClass { 
    // ... 
    KEY2000 = init(...); 
    } 

    // Keep generating nested classes for more constants... 
    private static class Constants3 ... {} 
} 

Answer 2

Jedną z możliwości byłoby użycie dziedziczenia - posiada szereg zajęć Constants1, Constants2, ..., ConstantsN że wszystko definiować stałe, wtedy każdy jeden dziedziczą z poprzedniej. Ostateczna klasa Constants może następnie bezpośrednio dziedziczyć z ostatniego z nich. Pozwala to również oznaczyć wszystko jako final.

Z ciekawości, w jaki sposób powstał plik tak duży, że nie można dopasować kodu inicjalizacyjnego do limitu 64 KB?

Mam nadzieję, że to pomoże!

Answer 3

Czy to nie działa? NIE. Zobacz komentarze, dlaczego taka odpowiedź nie rozwiąże problemu.

To pozwoli na zachowanie zmiennych statycznych i ułatwi automatyczne generowanie. Jednak java zwija wszystkie statyczne bloki init w jeden gigantyczny statyczny blok init, przez co problem nie został rozwiązany.

public class Constants extends SomeBaseClass { 

    // init() is defined in some base class... 
    public static final XXX KEY1 ; 
    static 
    { 
     KEY1 = init(...); 
    } 
    public static final XXX KEY2 ; 
    static 
    { 
     KEY2 = init(...); 
    } 
    public static final XXX KEY3 ; 
    static 
    { 
     KEY3 = init(...); 
    } 

    // ... 

} 

Answer 4

Możesz mieć tyle bloków inicjalizacji statycznej, ile chcesz.