¿Cómo se inyectan los servidores de aplicaciones en los campos privados?

Question

vi esta pregunta

Inject into private, package or public field or provide a setter?

sobre cómo inyectar manualmente en los campos privados anotados (La forma es la adición de los emisores oa través de un constructor)

embargo, la cuestión es cómo hacer un servidor de aplicaciones (como glassfish, axis2, jboss, ...) es capaz de inyectar en un campo privado final (sin agregar setters o constructores a la clase de usuario)?

Citando la pregunta citada:

public SomeClass { 
    @Inject 
    private SomeResource resource; 
} 

es lo que utilizan una JVM personalizada (no el estándar) que permite acceder a los campos privados?

Gracias

Answer 1

Es un simple reflejo "truco". Se basa en el método de Field.setAccessible() para forzar el miembro para ser accesible mediante programación:

establecer el indicador accesible para este objeto al valor booleano se indica. Un valor de verdadero indica que el objeto reflejado debe suprimir Java comprobación de acceso de idioma cuando es utilizado. Un valor de falso indica que el objeto reflejado debe hacer cumplir verificaciones de acceso de lenguaje Java.

La API Reflection se utiliza para obtener un control en el campo, se llama a setAccessible(), y luego se puede establecer mediante el marco de inyección.

Ver un ejemplo here.

No hay magia, no hay VM personalizada.

Answer 2

Con la ayuda de skaffman he codificado este sencillo ejemplo sobre cómo inyectar sin setters. Tal vez esto sirva (lo hicieron a mí) de salida

//...................................................... 
import java.lang.annotation.*; 
import java.lang.reflect.*; 

//...................................................... 
@Target(value = {ElementType.FIELD}) 
@Retention(RetentionPolicy.RUNTIME) 
@interface Inject { 
} 

//...................................................... 
class MyClass { 

    @Inject 
    private int theValue = 0; 

    public int getTheValue() { 
     return theValue; 
    } 
} // class 

//...................................................... 
public class Example { 

    //...................................................... 
    private static void doTheInjection(MyClass u, int value) throws IllegalAccessException { 

     Field[] camps = u.getClass().getDeclaredFields(); 

     System.out.println("------- fields : --------"); 
     for (Field f : camps) { 
      System.out.println(" -> " + f.toString()); 
      Annotation an = f.getAnnotation(Inject.class); 
      if (an != null) { 
       System.out.println("  found annotation: " + an.toString()); 
       System.out.println("  injecting !"); 
       f.setAccessible(true); 
       f.set(u, value); 
       f.setAccessible(false); 
      } 
     } 

    } //() 

    //...................................................... 
    public static void main(String[] args) throws Exception { 

     MyClass u = new MyClass(); 

     doTheInjection(u, 23); 

     System.out.println(u.getTheValue()); 

    } // main() 
} // class 

Run:

------- fields : -------- 
-> private int MyClass.theValue 
     found annotation: @Inject() 
     injecting ! 
23 

Answer 3

Es también digno de mención, que algunos marcos utilizan la ingeniería de código de bytes a través de un cargador de clases a medida para conseguir el mismo resultado sin el coste de reflexión (la reflexión puede ser bastante costosa a veces)