Cómo eludir el límite de tamaño de un inicializador estático en Java para inicializar grandes cantidades de constantes

Question

tengo una clase que sostiene una montura grande de constantes generados como tal:

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(...); 
} 

Cuando el número de constantes generados es muy alto, esto da como resultado un inicializador estático que es mayor que el límite superior para los tamaños de método de Java (es decir,> 64 kb), lo que da como resultado un error de compilación. Una solución es crear varios "métodos de inicialización de bloque" para bloques que pueden ser garantizados para producir menos de 64kb de código de bytes, de tal forma que encajan en un método:

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(...); 
    } 
} 

El inconveniente de esto es que lo que pueda ya no declara las constantes como final, porque ya no se inicializan directamente en el inicializador estático.

Mi pregunta es, ¿cómo puedo eludir esa limitación de compilador/JVM de manera que todavía puedo generar constantes static final?

Answer 1

Finalmente fui por una solución que involucraba clases anidadas. Esto fue sugerido en un comentario al this answer here por el usuario Loadmaster.clases anidadas tienen dos ventajas:

• Permiten para ocultar estos detalles de implementación solución desde el mundo exterior por ser private clases anidadas
• Permiten mantener constantes final

pero también tienen una desventaja en comparación con la solución templatetypedef's:

• Me encontraré con el mismo problema de nuevo con mucho lar ger los números de las constantes

En este momento, sin embargo, esto parece ser la solución más adecuada:

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

Una opción sería utilizar la herencia - tener una serie de clases Constants1, Constants2, ..., ConstantsN que todos definen las constantes, a continuación, tienen cada uno hereda de la anterior. La clase final Constants puede heredar directamente de la última de ellas. Esto también le permite marcar todo final.

Por curiosidad, ¿cómo terminaste con un archivo tan grande que no podías ajustar el código de inicialización en el límite de 64 KB?

Espero que esto ayude!

Answer 3

¿No funcionaría? NO. Vea los comentarios de por qué este tipo de respuesta no resolverá el problema.

Te permitiría mantener las variables estáticas finales y sería más fácil de autogenerar. Sin embargo, java colapsa todos los bloques estáticos de init en un bloque static init gigante y, por lo tanto, el problema no se resuelve.

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

Puede tener tantos bloques de inicialización estática como desee.