Change private static final field using Java reflection

Question

I have a class with a private static final field that  unfortunately  I need to change it at run-time   Using reflection I get this error  java lang IllegalAccessException  Can not set static final boolean field  Is there any way to change the value   Field hack   WarpTransform2D class getDeclaredField  USE HACK    hack setAccessible true   hack set null  true

User · Answer

The whole point of a final field is that it cannot be reassigned once set  The JVM uses this guarentee to maintain consistency in various places  eg inner classes referencing outer variables   So no  Being able to do so would break the JVM   The solution is not to declare it final in the first place

User · Answer

I also integrated it with joor library  Just use         Reflect on yourObject  set  finalFieldName   finalFieldValue     Also I fixed an issue with override which the previous solutions seem to miss  However use this very carefully  only when there s no other good solution

User · Answer

Even in spite of being final a field can be modified outside of static initializer and  at least JVM HotSpot  will execute the bytecode perfectly fine  The problem is that Java compiler does not allow this  but this can be easily bypassed using objectweb asm  Here is p e r f e c t l y   v a l i d   c l a s s f i l e  an invalid classfile from the JVMS specification standpoint  but it passes bytecode verification and then is successfully loaded and initialized under JVM HotSpot OpenJDK12  ClassWriter cw   new ClassWriter 0   cw visit Opcodes V1 8  Opcodes ACC PUBLIC   quot Cl quot   null   quot java lang Object quot   null         FieldVisitor fv   cw visitField Opcodes ACC PRIVATE   Opcodes ACC STATIC   Opcodes ACC FINAL   quot fld quot    quot I quot   null  null       fv visitEnd               public void setFinalField1                 MethodVisitor mv   cw visitMethod Opcodes ACC PUBLIC   Opcodes ACC STATIC   quot setFinalField1 quot    quot   V quot   null  null       mv visitMaxs 2  1       mv visitInsn Opcodes ICONST 5       mv visitFieldInsn Opcodes PUTSTATIC   quot Cl quot    quot fld quot    quot I quot        mv visitInsn Opcodes RETURN       mv visitEnd               public void setFinalField2                 MethodVisitor mv   cw visitMethod Opcodes ACC PUBLIC   Opcodes ACC STATIC   quot setFinalField2 quot    quot   V quot   null  null       mv visitMaxs 2  1       mv visitInsn Opcodes ICONST 2       mv visitFieldInsn Opcodes PUTSTATIC   quot Cl quot    quot fld quot    quot I quot        mv visitInsn Opcodes RETURN       mv visitEnd      cw visitEnd     In Java  the class looks roughly speaking as follows  public class Cl      private static final int fld       public static void setFinalField1            fld   5             public static void setFinalField2            fld   2           which cannot be compiled with javac  but can be loaded and executed by JVM  JVM HotSpot has special treatment of such classes in the sense that it prevents such  quot constants quot  from participating in constant folding  This check is done on the bytecode rewriting phase of class initialization     Check if any final field of the class given as parameter is modified    outside of initializer methods of the class  Fields that are modified    are marked with a flag  For marked fields  the compilers do not perform    constant folding  as the field can be changed after initialization         The check is performed after verification and only if verification has    succeeded  Therefore  the class is guaranteed to be well-formed  InstanceKlass  klass   method- gt method holder    u2 bc index   Bytes  get Java u2 bcp   prefix length   1   constantPoolHandle cp method- gt constants     Symbol  ref class name   cp- gt klass name at cp- gt klass ref index at bc index    if  klass- gt name      ref class name       Symbol  field name   cp- gt name ref at bc index      Symbol  field sig   cp- gt signature ref at bc index       fieldDescriptor fd     if  klass- gt find field field name  field sig   amp fd     NULL          if  fd access flags   is final               if  fd access flags   is static                  if   method- gt is static initializer                     fd set has initialized final update true                             else               if   method- gt is object initializer                    fd set has initialized final update true                                                        The only restriction that JVM HotSpot checks is that the final field should not be modified outside of the class that the final field is declared at

User · Answer

In case of presence of a Security Manager  one can make use of AccessController doPrivileged   Taking the same example from accepted answer above   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    amp   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            In lambda expression  AccessController doPrivileged  can be simplified to   AccessController doPrivileged  PrivilegedAction     - gt        modifiersField setAccessible true       return null

User · Answer

Along with top ranked answer you may use a bit simpliest approach  Apache commons FieldUtils class already has particular method that can do the stuff  Please  take a look at FieldUtils removeFinalModifier method  You should specify target field instance and accessibility forcing flag  if you play with non-public fields   More info you can find here

User · Answer

Many of the answers here are useful  but I ve found none of them to work on Android  in particular  I m even a pretty hefty user of Reflect by joor  and neither it nor apache s FieldUtils - both mentioned here in some of the answers  do the trick  Problem with Android The fundamental reason why this is so is because on Android there s no modifiers field in the Field class  which renders any suggestion involving this code  as in the marked answer   useless  Field modifiersField   Field class getDeclaredField  quot modifiers quot    modifiersField setAccessible true   modifiersField setInt field  field getModifiers    amp   Modifier FINAL    In fact  to quote from FieldUtils removeFinalModifier       Do all JREs implement Field with a private ivar called  quot modifiers quot   final Field modifiersField   Field class getDeclaredField  quot modifiers quot     So  the answer is no    Solution Pretty easy - instead of modifiers  the field name is accessFlags  This does the trick  Field accessFlagsField   Field class getDeclaredField  quot accessFlags quot    accessFlagsField setAccessible true   accessFlagsField setInt field  field getModifiers    amp   Modifier FINAL     Side-note  1  this can work regardless of whether the field is static in the class  or not    Side-note  2  Seeing that the field itself could be private  it s recommended to also enable access over the field itself  using field setAccessible true   in addition to accessFlagsField setAccessible true

User · Answer

Just saw that question on one of the interview question  if possible to change final variable with reflection or in runtime   Got really interested  so that what I became with            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              Some simple class with final String variable  So in the main class  import java lang reflect Field           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             The output will be as follows   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   According to documentation  https   docs oracle com javase tutorial reflect member fieldValues html

User · Answer

Assuming no SecurityManager is preventing you from doing this  you can use setAccessible to get around private and resetting the modifier to get rid of final  and actually modify a private static final field  Here s an example  import java lang reflect     public class EverythingIsTrue      static void setFinalStatic Field field  Object newValue  throws Exception         field setAccessible true          Field modifiersField   Field class getDeclaredField  quot modifiers quot          modifiersField setAccessible true         modifiersField setInt field  field getModifiers    amp   Modifier FINAL          field set null  newValue           public static void main String args    throws Exception               setFinalStatic Boolean class getField  quot FALSE quot    true          System out format  quot Everything is  s quot   false       quot Everything is true quot          Assuming no SecurityException is thrown  the above code prints  quot Everything is true quot   What s actually done here is as follows   The primitive boolean values true and false in main are autoboxed to reference type Boolean  quot constants quot  Boolean TRUE and Boolean FALSE Reflection is used to change the public static final Boolean FALSE to refer to the Boolean referred to by Boolean TRUE As a result  subsequently whenever a false is autoboxed to Boolean FALSE  it refers to the same Boolean as the one refered to by Boolean TRUE Everything that was  quot false quot  now is  quot true quot   Related questions  Using reflection to change static final File separatorChar for unit testing How to limit setAccessible to only    legitimate    uses   Has examples of messing with Integer s cache  mutating a String  etc     Caveats Extreme care should be taken whenever you do something like this  It may not work because a SecurityManager may be present  but even if it doesn t  depending on usage pattern  it may or may not work   JLS 17 5 3 Subsequent Modification of Final Fields In some cases  such as deserialization  the system will need to change the final fields of an object after construction  final fields can be changed via reflection and other implementation dependent means  The only pattern in which this has reasonable semantics is one in which an object is constructed and then the final fields of the object are updated  The object should not be made visible to other threads  nor should the final fields be read  until all updates to the final fields of the object are complete  Freezes of a final field occur both at the end of the constructor in which the final field is set  and immediately after each modification of a final field via reflection or other special mechanism  Even then  there are a number of complications  If a final field is initialized to a compile-time constant in the field declaration  changes to the final field may not be observed  since uses of that final field are replaced at compile time with the compile-time constant  Another problem is that the specification allows aggressive optimization of final fields  Within a thread  it is permissible to reorder reads of a final field with those modifications of a final field that do not take place in the constructor   See also  JLS 15 28 Constant Expression  It s unlikely that this technique works with a primitive private static final boolean  because it s inlineable as a compile-time constant and thus the  quot new quot  value may not be observable     Appendix  On the bitwise manipulation Essentially  field getModifiers    amp   Modifier FINAL  turns off the bit corresponding to Modifier FINAL from field getModifiers     amp  is the bitwise-and  and   is the bitwise-complement  See also  Wikipedia Bitwise operation   Remember Constant Expressions Still not being able to solve this   have fallen onto depression like I did for it  Does your code looks like this  public class A       private final String myVar    quot Some Value quot      Reading the comments on this answer  specially the one by  Pshemo  it reminded me that Constant Expressions are handled different so it will be impossible to modify it  Hence you will need to change your code to look like this  public class A       private final String myVar       private A             myVar    quot Some Value quot            if you are not the owner of the class    I feel you  For more details about why this behavior read this

User · Answer

If your field is simply private you can do this   MyClass myClass  new MyClass    Field aField  myClass getClass   getDeclaredField  someField    aField setAccessible true   aField set myClass   newValueForAString      and throw handle NoSuchFieldException

User · Answer

If the value assigned to a static final boolean field is known at compile-time  it is a constant  Fields of primitive or  String type can be compile-time constants  A constant will be inlined in any code that references the field  Since the field is not actually read at runtime  changing it then will have no effect   The Java language specification says this      If a field is a constant variable      4 12 4   then deleting the keyword   final or changing its value will not   break compatibility with pre-existing   binaries by causing them not to run    but they will not see any new value   for the usage of the field unless they   are recompiled  This is true even if   the usage itself is not a compile-time   constant expression    15 28    Here s an example   class Flag     static final boolean FLAG   true     class Checker     public static void main String    argv        System out println Flag FLAG           If you decompile Checker  you ll see that instead of referencing Flag FLAG  the code simply pushes a value of 1  true  onto the stack  instruction  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

User · Answer

A little curiosity from the Java Language Specification  chapter 17  section 17 5 4  Write-protected Fields       Normally  a field that is final and static may not be modified    However  System in  System out  and System err are static final fields   that  for legacy reasons  must be allowed to be changed by the methods   System setIn  System setOut  and System setErr  We refer to these   fields as being write-protected to distinguish them from ordinary   final fields    Source  http   docs oracle com javase specs jls se7 html jls-17 html jls-17 5 4

User · Answer

The accepted answer worked for me until deployed on JDK 1 8u91  Then I realized it failed at field set null  newValue   line when I had read the value via reflection before calling of setFinalStatic method   Probably the read caused somehow different setup of Java reflection internals  namely sun reflect UnsafeQualifiedStaticObjectFieldAccessorImpl in failing case instead of sun reflect UnsafeStaticObjectFieldAccessorImpl in success case  but I didn t elaborate it further   Since I needed to temporarily set new value based on old value and later set old value back  I changed signature little bit to provide computation function externally and also return old value   public static  lt T gt  T assignFinalField Object object  Class lt   gt  clazz  String fieldName  UnaryOperator lt T gt  newValueFunction        Field f   null  ff   null      try           f   clazz getDeclaredField fieldName           final int oldM   f getModifiers            final int newM   oldM  amp   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              However for general case this would not be sufficient

[java] Change private static final field using Java reflection

Examples related to java

Examples related to reflection

Examples related to static

Examples related to private

Examples related to final