Zmiana prywatnego statycznego pola końcowego przy użyciu Java reflection

Jeśli wartość przypisana do pola static final boolean jest znana w czasie kompilacji, jest to stała . pola prymitywne lub String Typ może być stałymi czasu kompilacji. Stała będzie inlined w każdym kodzie, który odwołuje się do pola. Ponieważ pole nie jest w rzeczywistości odczytywane w czasie wykonywania, jego zmiana nie będzie miała żadnego wpływu.

Specyfikacja języka Java mówi tak:

Jeśli pole jest stałą zmienną (§4.12.4), a następnie usunięcie słowa kluczowego finał zmiana jego wartości nie będzie zerwać kompatybilność z istniejącymi wcześniej binaria, powodując, że nie uruchamiają się, ale nie zobaczą żadnej nowej wartości za korzystanie z pola, chyba że są rekompilowane. to prawda, nawet jeśli samo użycie nie jest czasem kompilacji wyrażenie stałe (§15.28)

Oto przykład:

class Flag {
  static final boolean FLAG = true;
}

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

Jeśli dekompilujesz Checker, zobaczysz, że zamiast odwoływać się do Flag.FLAG, kod po prostu wypycha wartość 1 (true) na stos (Instrukcja # 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

Mała ciekawostka ze specyfikacji języka Java, Rozdział 17, sekcja 17.5.4 "pola chronione przed zapisem":

Zwykle pole, które jest ostateczne i statyczne, nie może być modyfikowane. Jednakże, System.in, System.out, i System.err są statycznymi polami końcowymi które, ze względów historycznych, muszą być dopuszczone do zmiany za pomocą metod System.setIn, System.setOut i System.setErr. Odnosimy się do tych pola jako zabezpieczone przed zapisem w celu odróżnienia ich od zwykłych finał pola.

Źródło: http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.5.4

Zintegrowałem go również z biblioteką joor

Po prostu użyj

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

Naprawiłem również problem z override, który wydaje się brakować w poprzednich rozwiązaniach. Jednak używaj tego bardzo ostrożnie, tylko wtedy, gdy nie ma innego dobrego rozwiązania.

W przypadku obecności menedżera bezpieczeństwa można skorzystać z AccessController.doPrivileged

Biorąc ten sam przykład z zaakceptowanej odpowiedzi powyżej:

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

W wyrażeniu lambda, AccessController.doPrivileged, można uprościć do:

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

Wraz z najwyżej ocenioną odpowiedzią możesz użyć nieco prostszego podejścia. Klasa Apache commons FieldUtils ma już określoną metodę, która może to robić. Proszę spojrzeć na metodę FieldUtils.removeFinalModifier. Należy określić instancję pola docelowego i flagę wymuszania dostępności (jeśli grasz z polami niepublicznymi). Więcej informacji można znaleźć TUTAJ .

Zaakceptowana odpowiedź działała dla mnie do momentu wdrożenia na JDK 1. 8u91. Potem zdałem sobie sprawę, że nie powiodło się w linii field.set(null, newValue);, Kiedy odczytałem wartość przez odbicie przed wywołaniem metody setFinalStatic.

Prawdopodobnie odczyt spowodował nieco inną konfigurację wewnętrznych odbić Javy (mianowicie sun.reflect.UnsafeQualifiedStaticObjectFieldAccessorImpl w przypadku niepowodzenia zamiast sun.reflect.UnsafeStaticObjectFieldAccessorImpl w przypadku sukcesu), ale nie rozwinąłem tego dalej.

Ponieważ musiałem tymczasowo ustawić nową wartość na podstawie starej wartości, a później ustawić starą wartość z powrotem, zmieniłem podpis trochę, aby zapewnić funkcję obliczeniową zewnętrznie, a także zwrócić starą wartość:

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

Jednakże w przypadku ogólnym nie byłoby to wystarczające.

Właśnie widziałem to pytanie na jednym z pytań wywiadu, jeśli to możliwe, aby zmienić ostateczną zmienną z odbiciem lub w uruchomieniu. Bardzo mnie to zainteresowało, więc czym się stałem:

 /**
 * @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();
    }
}

Jakaś prosta klasa z końcową zmienną łańcuchową. Więc w głównej klasie Importuj Javę.lang.zastanów się.Pole;

/**
 * @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);
    }
}

Wynik będzie następujący:

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

Zgodnie z dokumentacją https://docs.oracle.com/javase/tutorial/reflect/member/fieldValues.html

Cały punkt pola final jest taki, że nie można go ponownie przypisać raz ustawione. JVM używa tej gwarancji do zachowania spójności w różnych miejscach (np. klasy wewnętrzne odwołujące się do zmiennych zewnętrznych). Więc nie. Być w stanie to zrobić złamie JVM!

Rozwiązaniem nie jest zadeklarowanie go final w pierwszej kolejności.