Access static final variable using reflection
Accessing static fields is done exactly the same way as normal fields, only you don't need to pass any argument to Field.get()
method (you can pass a null).
Try this:
Object getFieldValue(String path) throws Exception {
int lastDot = path.lastIndexOf(".");
String className = path.substring(0, lastDot);
String fieldName = path.substring(lastDot + 1);
Class myClass = Class.forName(className);
Field myField = myClass.getDeclaredField(fieldName);
return myField.get(null);
}
changing final variables through reflection, why difference between static and non-static final variable
FinalReflectionobj = new FinalReflection();
System.out.println(FinalReflection.stmark);
System.out.println(obj.inmark);
Field staticFinalField = FinalReflection.class.getDeclaredField("stmark");
Field instanceFinalField = FinalReflection.class.getDeclaredField("inmark");
staticFinalField.setAccessible(true);
instanceFinalField.setAccessible(true);
//EXTRA CODE
//Modify the final using reflection
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(staticFinalField, staticFinalField.getModifiers() & ~Modifier.FINAL);
instanceFinalField.set(obj, 100);
System.out.println(obj.inmark);
staticFinalField.set(FinalReflection.class, 101);
System.out.println(FinalReflection.stmark);
This solution does not come without some downsides, it may not work in all cases:
In case a final
field is initialized to a compile-time constant in the field declaration, changes to the final
field may not be visible, 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.
More on this is also explained in this similar question.
Getting value of public static final field/property of a class in Java via reflection
First retrieve the field property of the class, then you can retrieve the value. If you know the type you can use one of the get methods with null (for static fields only, in fact with a static field the argument passed to the get method is ignored entirely). Otherwise you can use getType and write an appropriate switch as below:
Field f = R.class.getField("_1st");
Class<?> t = f.getType();
if(t == int.class){
System.out.println(f.getInt(null));
}else if(t == double.class){
System.out.println(f.getDouble(null));
}...
Change private static final field using Java reflection
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("modifiers");
modifiersField.setAccessible(true);
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"
}
}
Assuming no SecurityException
is thrown, the above code prints "Everything is true"
.
What's actually done here is as follows:
- The primitive
boolean
valuestrue
andfalse
inmain
are autoboxed to reference typeBoolean
"constants"Boolean.TRUE
andBoolean.FALSE
- Reflection is used to change the
public static final Boolean.FALSE
to refer to theBoolean
referred to byBoolean.TRUE
- As a result, subsequently whenever a
false
is autoboxed toBoolean.FALSE
, it refers to the sameBoolean
as the one refered to byBoolean.TRUE
- Everything that was
"false"
now is"true"
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 aString
, etc
- Has examples of messing with
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 thefinal
fields of the object are updated. The object should not be made visible to other threads, nor should thefinal
fields be read, until all updates to thefinal
fields of the object are complete. Freezes of afinal
field occur both at the end of the constructor in which thefinal
field is set, and immediately after each modification of afinal
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 thefinal
field may not be observed, since uses of thatfinal
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 afinal
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 "new" value may not be observable
- It's unlikely that this technique works with a primitive
Appendix: On the bitwise manipulation
Essentially,
field.getModifiers() & ~Modifier.FINAL
turns off the bit corresponding to Modifier.FINAL
from field.getModifiers()
. &
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 = "Some Value";
}
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 = "Some Value";
}
}
if you are not the owner of the class... I feel you!
For more details about why this behavior read this?
Java reflection to set static final field fails after previous reflection
If you want the modifier hack (don't forget it is a total hack) to work, you need to change the modifiers
private field before the first time you access the field.
So, before you do f.getInt(null);
, you need to do:
mf.setInt(f, f.getModifiers() & ~Modifier.FINAL);
The reason is that only one internal FieldAccessor
object is created for each field of a class (*), no matter how many different actual java.lang.reflect.Field
objects you have. And the check for the final
modifier is done once when it constructs the FieldAccessor implementation in the UnsafeFieldAccessorFactory
.
When it is determined you can't access final static
fields (because, the setAccessible
override doesn't works but non-static final fields, but not for static
final fields), it will keep failing for every subsequent reflection, even through a different Field
object, because it keeps using the same FieldAccessor
.
(*) barring synchronization issues; as the source code for Field
mentions in a comment:
// NOTE that there is no synchronization used here. It is correct
(though not efficient) to generate more than one FieldAccessor for a
given Field.
Change static final field in java 12+
You can use Unsafe
.
public class Example
{
// javac will inline static final Strings, so let's say it's Object
private static final Object changeThis = "xxx";
public static void main(String... args) throws Exception
{
final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
unsafeField.setAccessible(true);
final Unsafe unsafe = (Unsafe) unsafeField.get(null);
System.out.println("before = " + changeThis);
final Field ourField = Example.class.getDeclaredField("changeThis");
final Object staticFieldBase = unsafe.staticFieldBase(ourField);
final long staticFieldOffset = unsafe.staticFieldOffset(ourField);
unsafe.putObject(staticFieldBase, staticFieldOffset, "it works");
System.out.println("after = " + changeThis);
}
}
Result:
before = xxx
after = it works
Related Topics
Lists with Wildcards Cause Generic Voodoo Error
How to Split Array List into Equal Parts
Block()/Blockfirst()/Blocklast() Are Blocking Error When Calling Bodytomono After Exchange()
How to Make a Countdown Timer in Java
Constructor Synchronization in Java
Capture Generated Dynamic Content at Server Side
How to Make Hashmap Work with Arrays as Key
How to Deserialize a Blank JSON String Value to Null for Java.Lang.String
Using a Prepared Statement and Variable Bind Order by in Java with Jdbc Driver
Is There a Java Library to Access the Native Windows API
Using Sha1 and Rsa with Java.Security.Signature VS. Messagedigest and Cipher
Determine Whether Daylight Savings Time (Dst) Is Active in Java for a Specified Date
JPA - Returning an Auto Generated Id After Persist()
Reflections - Java 8 - Invalid Constant Type
Which Loop Has Better Performance? Why
Data Structures That Can Map a Range of Keys to a Value
When Do You Need to Explicitly Call a Superclass Constructor