Cambiar el campo final estático privado usando Java reflection

Si el valor asignado a un campo static final boolean es conocido en tiempo de compilación, es una constante . Campos de primitivo o String type puede ser constante en tiempo de compilación. Una constante se insertará en cualquier código que haga referencia al campo. Dado que el campo no se lee realmente en tiempo de ejecución, cambiarlo no tendrá ningún efecto.

La especificación del lenguaje Java dice esto:

Si un campo es una variable constante (§4.12.4), luego eliminar la palabra clave final o cambiar su valor no romper la compatibilidad con preexistentes binarios haciendo que no se ejecuten, pero no verán ningún valor nuevo para el uso del campo a menos que son recompilados. Esto es cierto incluso si el uso en sí no es un tiempo de compilación expresión constante (§15.28)

Aquí hay un ejemplo:

class Flag {
  static final boolean FLAG = true;
}

class Checker {
  public static void main(String... argv) {
    System.out.println(Flag.FLAG);
  }
}

Si descompilar Checker, verás que en lugar de hacer referencia a Flag.FLAG, el código, simplemente presiona un valor de 1 (true) en la pila (instrucción #3).

0:   getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
3:   iconst_1
4:   invokevirtual   #3; //Method java/io/PrintStream.println:(Z)V
7:   return

Una pequeña curiosidad de la Especificación del lenguaje Java, capítulo 17, sección 17.5.4 "Campos protegidos contra escritura":

Normalmente, un campo que es final y estático no puede ser modificado. Sin embargo, System.in, Sistema.fuera, y el Sistema.err son campos finales estáticos que, por razones heredadas, debe permitirse ser cambiado por los métodos Sistema.setIn, Sistema.setOut y Sistema.setErr. Nos referimos a estos campos protegidos contra escritura para distinguirlos de los ordinarios final campo.

Fuente: http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.5.4

También lo integré con joor library

Solo use

      Reflect.on(yourObject).setFinal("finalFieldName", finalFieldValue);

También he corregido un problema con override que las soluciones anteriores parecen perder. Sin embargo, utilice esto con mucho cuidado, solo cuando no hay otra buena solución.

En caso de presencia de un Administrador de seguridad, uno puede hacer uso de AccessController.doPrivileged

Tomando el mismo ejemplo de la respuesta aceptada arriba:

import java.lang.reflect.*;

public class EverythingIsTrue {
    static void setFinalStatic(Field field, Object newValue) throws Exception {
        field.setAccessible(true);
        Field modifiersField = Field.class.getDeclaredField("modifiers");

        // wrapping setAccessible 
        AccessController.doPrivileged(new PrivilegedAction() {
            @Override
            public Object run() {
                modifiersField.setAccessible(true);
                return null;
            }
        });

        modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
        field.set(null, newValue);
    }

    public static void main(String args[]) throws Exception {      
      setFinalStatic(Boolean.class.getField("FALSE"), true);
      System.out.format("Everything is %s", false); // "Everything is true"
    }
}

En la expresión lambda, AccessController.doPrivileged, se puede simplificar a:

AccessController.doPrivileged((PrivilegedAction) () -> {
    modifiersField.setAccessible(true);
    return null;
});

Junto con la respuesta mejor clasificada, puede usar un enfoque un poco más simple. La clase Apache commons FieldUtils ya tiene un método particular que puede hacer las cosas. Por favor, eche un vistazo al método FieldUtils.removeFinalModifier. Debe especificar la instancia del campo de destino y el indicador de forzamiento de accesibilidad (si juega con campos no públicos). Más información puede encontrar aquí.

La respuesta aceptada funcionó para mí hasta que se implementó en JDK 1.8u91. Entonces me di cuenta de que falló en la línea field.set(null, newValue); cuando había leído el valor a través de reflexión antes de llamar al método setFinalStatic.

Probablemente la lectura causó de alguna manera una configuración diferente de los internos de reflexión de Java (a saber, sun.reflect.UnsafeQualifiedStaticObjectFieldAccessorImpl en caso de fallo en lugar de sun.reflect.UnsafeStaticObjectFieldAccessorImpl en caso de éxito), pero no lo elaboré más.

Dado que necesitaba establecer temporalmente un nuevo valor basado en el valor anterior y luego volver a establecer el valor anterior, cambié la firma poco para proporcionar la función de cálculo externamente y también devolver el valor antiguo:

public static <T> T assignFinalField(Object object, Class<?> clazz, String fieldName, UnaryOperator<T> newValueFunction) {
    Field f = null, ff = null;
    try {
        f = clazz.getDeclaredField(fieldName);
        final int oldM = f.getModifiers();
        final int newM = oldM & ~Modifier.FINAL;
        ff = Field.class.getDeclaredField("modifiers");
        ff.setAccessible(true);
        ff.setInt(f,newM);
        f.setAccessible(true);

        T result = (T)f.get(object);
        T newValue = newValueFunction.apply(result);

        f.set(object,newValue);
        ff.setInt(f,oldM);

        return result;
    } ...

Sin embargo, para el caso general esto no sería suficiente.

Acabo de ver esa pregunta en una de las preguntas de la entrevista, si es posible cambiar la variable final con reflexión o en tiempo de ejecución. Me interesé mucho, por lo que me convertí en:

 /**
 * @author Dmitrijs Lobanovskis
 * @since 03/03/2016.
 */
public class SomeClass {

    private final String str;

    SomeClass(){
        this.str = "This is the string that never changes!";
    }

    public String getStr() {
        return str;
    }

    @Override
    public String toString() {
        return "Class name: " + getClass() + " Value: " + getStr();
    }
}

Alguna clase simple con la variable de cadena final. Así que en la clase principal importar java.lang.reflejar.Campo;

/**
 * @author Dmitrijs Lobanovskis
 * @since 03/03/2016.
 */
public class Main {


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

        SomeClass someClass = new SomeClass();
        System.out.println(someClass);

        Field field = someClass.getClass().getDeclaredField("str");
        field.setAccessible(true);

        field.set(someClass, "There you are");

        System.out.println(someClass);
    }
}

La salida será la siguiente:

Class name: class SomeClass Value: This is the string that never changes!
Class name: class SomeClass Value: There you are

Process finished with exit code 0

Según la documentación https://docs.oracle.com/javase/tutorial/reflect/member/fieldValues.html

El punto de un campo final es que no se puede reasignar una vez establecido. La JVM utiliza esta garantía para mantener la consistencia en varios lugares (por ejemplo, clases internas que hacen referencia a variables externas). Así que no. Ser capaz de hacerlo rompería la JVM!

La solución no es declararlo final en primer lugar.