-
- All Implemented Interfaces:
public class Reflect
A wrapper for an Object or Class upon which reflective calls can be made.
An example of using
Reflect
is// Static import all reflection methods to decrease verbosity import static org.joor.Reflect.*; // Wrap an Object / Class / class name with the on() method: on("java.lang.String") // Invoke constructors using the create() method: .create("Hello World") // Invoke methods using the call() method: .call("toString") // Retrieve the wrapped object
-
-
Method Summary
Modifier and Type Method Description static Reflect
on(String name)
Wrap a class name. static Reflect
on(String name, ClassLoader classLoader)
Wrap a class name, loading it via a given class loader. static Reflect
on(Class<out Object> clazz)
Wrap a class. static Reflect
on(Object object)
Wrap an object. static <T extends AccessibleObject> T
accessible(T accessible)
Conveniently render an AccessibleObject accessible. <T> T
get()
Get the wrapped object Reflect
set(String name, Object value)
Set a field value. <T> T
get(String name)
Get a field value. Reflect
field(String name)
Get a wrapped field. Map<String, Reflect>
fields()
Get a Map containing field names and wrapped values for the fields' values. Reflect
call(String name)
Call a method by its name. Reflect
call(String name, Array<Object> args)
Call a method by its name. Reflect
create()
Call a constructor. Reflect
create(Array<Object> args)
Call a constructor. <P> P
as(Class<P> proxyType)
Create a proxy for the wrapped object allowing to typesafely invoke methods on it using a custom interface int
hashCode()
boolean
equals(Object obj)
String
toString()
Class<out Object>
type()
Get the type of the wrapped object. static Class<out Object>
wrapper(Class<out Object> type)
Get a wrapper type for a primitive type, or the argument type itself, if it is not a primitive type. -
-
Method Detail
-
on
static Reflect on(String name)
Wrap a class name.
This is the same as calling
on(Class.forName(name))
- Parameters:
name
- A fully qualified class name
-
on
static Reflect on(String name, ClassLoader classLoader)
Wrap a class name, loading it via a given class loader.
This is the same as calling
on(Class.forName(name, classLoader))
- Parameters:
name
- A fully qualified class name.classLoader
- The class loader in whose context the class should be loaded.
-
on
static Reflect on(Class<out Object> clazz)
Wrap a class.
Use this when you want to access static fields and methods on a Class object, or as a basis for constructing objects of that class using create
- Parameters:
clazz
- The class to be wrapped
-
on
static Reflect on(Object object)
Wrap an object.
Use this when you want to access instance fields and methods on any Object
- Parameters:
object
- The object to be wrapped
-
accessible
static <T extends AccessibleObject> T accessible(T accessible)
Conveniently render an AccessibleObject accessible.
To prevent SecurityException, this is only done if the argument object and its declaring class are non-public.
- Parameters:
accessible
- The object to render accessible
-
set
Reflect set(String name, Object value)
Set a field value.
This is roughly equivalent to set. If the wrapped object is a Class, then this will set a value to a static member field. If the wrapped object is any other Object, then this will set a value to an instance member field.
This method is also capable of setting the value of (static) final fields. This may be convenient in situations where no SecurityManager is expected to prevent this, but do note that (especially static) final fields may already have been inlined by the javac and/or JIT and relevant code deleted from the runtime verison of your program, so setting these fields might not have any effect on your execution.
For restrictions of usage regarding setting values on final fields check: http://stackoverflow.com/questions/3301635/change-private-static-final-field-using-java-reflection ... and http://pveentjer.blogspot.co.at/2017/01/final-static-boolean-jit.html
- Parameters:
name
- The field namevalue
- The new field value
-
get
<T> T get(String name)
Get a field value.
This is roughly equivalent to get. If the wrapped object is a Class, then this will get a value from a static member field. If the wrapped object is any other Object, then this will get a value from an instance member field.
If you want to "navigate" to a wrapped version of the field, use field instead.
- Parameters:
name
- The field name
-
field
Reflect field(String name)
Get a wrapped field.
This is roughly equivalent to get. If the wrapped object is a Class, then this will wrap a static member field. If the wrapped object is any other Object, then this wrap an instance member field.
- Parameters:
name
- The field name
-
fields
Map<String, Reflect> fields()
Get a Map containing field names and wrapped values for the fields' values.
If the wrapped object is a Class, then this will return static fields. If the wrapped object is any other Object, then this will return instance fields.
These two calls are equivalent
on(object).field("myField"); on(object).fields().get("myField");
-
call
Reflect call(String name)
Call a method by its name.
This is a convenience method for calling
call(name, new Object[0])
- Parameters:
name
- The method name
-
call
Reflect call(String name, Array<Object> args)
Call a method by its name.
This is roughly equivalent to invoke. If the wrapped object is a Class, then this will invoke a static method. If the wrapped object is any other Object, then this will invoke an instance method.
Just like invoke, this will try to wrap primitive types or unwrap primitive type wrappers if applicable. If several methods are applicable, by that rule, the first one encountered is called. i.e. when calling
The first of the following methods will be called:on(...).call("method", 1, 1);
public void method(int param1, Integer param2); public void method(Integer param1, int param2); public void method(Number param1, Number param2); public void method(Number param1, Object param2); public void method(int param1, Object param2);
The best matching method is searched for with the following strategy:
- public method with exact signature match in class hierarchy
- non-public method with exact signature match on declaring class
- public method with similar signature in class hierarchy
- non-public method with similar signature on declaring class
- Parameters:
name
- The method nameargs
- The method arguments
-
create
Reflect create()
Call a constructor.
This is a convenience method for calling
create(new Object[0])
-
create
Reflect create(Array<Object> args)
Call a constructor.
This is roughly equivalent to newInstance. If the wrapped object is a Class, then this will create a new object of that class. If the wrapped object is any other Object, then this will create a new object of the same type.
Just like newInstance, this will try to wrap primitive types or unwrap primitive type wrappers if applicable. If several constructors are applicable, by that rule, the first one encountered is called. i.e. when calling
The first of the following constructors will be applied:on(C.class).create(1, 1);
public C(int param1, Integer param2); public C(Integer param1, int param2); public C(Number param1, Number param2); public C(Number param1, Object param2); public C(int param1, Object param2);
- Parameters:
args
- The constructor arguments
-
as
<P> P as(Class<P> proxyType)
Create a proxy for the wrapped object allowing to typesafely invoke methods on it using a custom interface
- Parameters:
proxyType
- The interface type that is implemented by the proxy
-
hashCode
int hashCode()
-
-
-
-