Basics of reflection in java

SINF2335:Prog.Paradigms:
Theory,Pract.andApplic.
Lecture 9 : 
Basics of Reflection in Java
LSINF 2335
Programming Paradigms
Prof. Kim Mens
UCL / EPL / INGI
(Slides partly based on the 
book “Java Reflection in Action”, on
The Java Tutorials, and on 
slides by Pr. Walter Cazzola)

Some References
2
Ira R. Forman
Nate Forman
M A N N I N G
Sample Chapter

■ About reflection in Java
■ Example of a reflective Java program
■ The Java meta-object protocol
■ The Java reflection API
– Class
– Field, Method and Constructor
■ Metaclass madness
■ Java's dynamic proxies
■ Reflective features in Java 1.5
3

– Class
■ History of reflection in Java
4

Theory,Pract.andApplic. Reflection, reification,
introspection & intercession
■ (Computational) reflection: ability of a running
program to inspect and change itself.
■ Reification: making the language concepts (meta-
level) accessible (at base level) to the program, so
that they can be manipulated as ordinary data.
■ Introspection: self-examination; only looking at
the reified entities.
■ Intercession: when you actually intervene in the
program execution as well (by manipulating those
reified entities)
5

6
About Reflection in Java
■ Java provides an API for reflection
– a rich set of operations for introspection
– few intercession capabilities
■ Can be used to examine or modify the runtime
behaviour of applications running in the JVM
■ Warning
– is a pretty advanced feature
• should be used only by developers who have a strong grasp of the
fundamentals of the language
– when to avoid it
• in performance-sensitive applications
• in security-related code
• may expose some internals (e.g. accessing of private fields)

– Class
7

An Illustrative Example
8
(Taken from Chapter 1 of the
book “Java Reflection in
Action” by Forman & Forman.)
■ User interface implementation
■ Contains several visual components (classes)
– some developed in-house
– some open source
– some belong the standard Java libraries
– some are bought
■ All these components understand
– setColor(Color aColor)
■ Problem: how to invoke this method?
– the components share no common supertype of interface
– only common base class is Object

public class Component4 {
Color myColor;
public void setColor(Color color) {
myColor = color;
}
...
}
Color myColor;
myColor = color;
}
...
}
9
Color myColor;
myColor = color;
}
...
}
Color myColor;
myColor = color;
}
...
}

What’s the problem?
10
public class Main {
static Object[] components = new Object[10];
static Color color = new Color(0);
public static void initializeComponents() {
components[0] = new Component1();
... }
public static void main(String[] args) {
initializeComponents();
for (int i = 0; i < args.length; i++)
if (components[i] != null)
components[i].setColor(color);
}
}
The method setColor(color) is undefined for the type Object

Possible solutions?
11
■ Define setColor on Object
– not a nice solution; not possible anyway
■ Use a typecast
– impossible: Object is the only common supertype
■ Make components implement common interface
– would work : we can use that interface as common type
– unfortunately some code is not ours: cannot be changed
■ Use an adapter for each component
– i.e. a “fake” component that delegates to the real one
– all adapters implement a common interface
– works, but explosion of extra classes and objects

More solutions?
12
■ Use instanceOf and casting
if (components[i] instanceof Component1)
((Component1) components[i]).setColor(color);
if (components[i] instanceof Component2)
((Component2) components[i]).setColor(color);
...
– works, but code bloated with conditionals and calls
– and concrete types hard-coded in the code
■ Why not use reflection?
– to find the right setColor method to call
– and invoke it using reflection

Reflective solution
13
public class Main {
static Object[] components = new Object[10];
static Color color = new Color(0);
public static void initializeComponents() {
... }
public static void main(String[] args) {
initializeComponents();
for (int i = 0; i < args.length; i++)
if (components[i] != null)
setObjectColor(components[i],color);
}
...
} Reflective method

Reflective solution
14
public static void setObjectColor( Object obj, Color color ) { 
Class cls = obj.getClass();
try {
Method method = cls.getMethod( "setColor",
new Class[] {Color.class} );
method.invoke( obj, new Object[] {color} );
}
catch (NoSuchMethodException ex) {
throw new IllegalArgumentException(
cls.getName()
+ " does not support method setColor(Color)" );
}
catch (IllegalAccessException ex) {
"Insufficient access permissions to call"
+ "setColor(:Color) in class " + cls.getName());
}
catch (InvocationTargetException ex) {
throw new RuntimeException(ex);
}
}

Reflective solution
15
public static void setObjectColor( Object obj, Color color ) {
try {
}
cls.getName()
}
}
}
}
Query obj for its class

Reflective solution
16
try {
}
cls.getName()
}
}
}
}
Query class object
for setColor method

Reflective solution
17
try {
}
cls.getName()
}
}
}
}
Call resulting
method on target
obj

Reflective solution
18
try {
}
cls.getName()
}
}
}
}
Catch error if class
obj does not support
setColor method

Reflective solution
19
try {
}
cls.getName()
}
}
}
}
Catch error if invoker
cannot call setColor method

Reflective solution
20
try {
}
cls.getName()
}
}
}
}
Catch error if method
setColor throws exception

21
■ Introspection
– query object for its class
– query class for its methods
■ Dynamic invocation
– dynamically call method at run-time 
without specifying which one at compile-time
■ Care should be taken to handle all exceptions
■ This solution is
– flexible and elegant
– though somewhat verbose
– but has some performance penalties

– Class
22

The Java Meta-Object Protocol
23
Point aPoint = new Point(2,3) 
aPoint.getClass()
➡ class Point
Class aClass = aPoint.getClass() 
aClass.getClass()
➡ class java.lang.Class
Class aMeta = aClass.getClass() 
aMeta.getClass()
Class aMetaMeta = aMeta.getClass() 
aMetaMeta.getClass()
Point
aPoint
getClass()
Class
getClass()
getClass()

■ Objects are instances of a class
■ Classes are instances of the meta class Class
■ The meta class Class is an instance of itself
Class Metaclass
ObjectObjectObjectObjectObject
Point Class
ObjectObjectObjectObjectaPoint
The metaclass loop in Java
instance of

Theory,Pract.andApplic. The Java Meta-Object Protocol
Object
Class Point
instance of
subclass of
Field
Method
Constructor
Member
implements
interface

– Class
26

The Java Reflection API
■ The Java Core Reflection API
– provides a small, type-safe, and secure API
– that supports introspection about the classes and
objects in the current JVM
– If permitted by security policy, the API can be used to:
• construct new class instances and new arrays
• access and modify fields of objects and classes
• invoke methods on objects and classes
• access and modify elements of arrays
– Intercession on classes and objects is forbidden 
27

The Java Reflection API
■ java.lang.reflect is in a subpackage of java.lang
■ Defines the following classes and methods:
– The classes Field, Method and Constructor
• reflect class and interface members and constructors
• provide reflective information about the underlying member or
constructor
• a type-safe means to use the member or constructor to operate on
Java objects
– Methods of class Class that enable the construction of new
instances of the Field, Method and Constructor classes.
– and more...
■ There are also some parts of the java.lang package
that support reflection
– In particular the class Class 28

– Class
29

Class
■ Instances of the class Class represent classes and
interfaces in a running Java application.
– Every array also belongs to a class that is reflected as a Class
object
• shared by all arrays with same element type and dimension
– Primitive Java types (boolean, byte, char, int, ...), and void are
also represented as Class objects
■ Class has no public constructor
– Class objects are constructed automatically by the Java Virtual
Machine as classes are loaded
– and by calls to defineClass method in the class loader
■ Defined in java.lang (instead of java.lang.reflect)
30

Using Class: examples
■ Using a Class object to print the class name of an
object:
void printClassName(Object obj) {
System.out.println("The class of " + obj + " is "
+ obj.getClass().getName());
}
■ Getting the Class object for a named type using a
class literal:
System.out.println("The name of class Foo is:"
+ Foo.class.getName());
31

Class: querying for methods
32
knows that setObjectColor always wants a method that takes one Color argument.
He specifies this using Color.class.
Class has other methods for introspecting about methods. The signatures and
return types for these methods are shown in table 1.1. As in the previous example,
the queries use an array of Class to indicate the types of the parameters. In
Table 1.1 The methods defined by Class for method query
Method Description
Method getMethod( String name,
Class[] parameterTypes )
Returns a Method object that represents a public
method (either declared or inherited) of the target
Class object with the signature specified by the
second parameters
Method[] getMethods() Returns an array of Method objects that represent
all of the public methods (either declared or inher-
ited) supported by the target Class object
Method getDeclaredMethod(
String name,
Class[] parameterTypes )
Returns a Method object that represents a
declared method of the target Class object with
the signature specified by the second parameters
Method[] getDeclaredMethods() Returns an array of Method objects that represent
all of the methods declared by the target Class
object
+ getConstructor, getField, ...

Theory,Pract.andApplic. Class: dealing with type
representation
33
Representing types with class objects
Java represents primitive, array, and interface types by introducing class objects
represent them. These class objects cannot do everything that many other cl
objects can. For instance, you cannot create a new instance of a primitive or int
Table 1.2 Methods defined by Class that deal with type representation
Method Description
String getName() Returns the fully qualified name of the target Class object
Class getComponentType() If the target object is a Class object for an array, returns the
Class object representing the component type
boolean isArray() Returns true if and only if the target Class object repre-
sents an array
boolean isInterface() Returns true if and only if the target Class object repre-
sents an interface
boolean isPrimitive() Returns true if and only if the target Class object repre-
sents a primitive type or void

– Class
34

Field, Method and Constructor
■ Three classes to reason about Java members
■ Only JVM may create instances of these classes
– i.e., they are final
■ Can be used to manipulate the underlying objects
– get reflective information about the underlying member
– get and set field values
– invoke methods on objects or classes
– create new instances of classes
■ These classes all implement the Member interface
– defines methods to query member for basic information:
• the class implementing a member
• the Java language modifiers for the member
35

Field
■ A Field object represents a reified field
– may be a class variable (a static field)
– or an instance variable (a non-static field)
■ Methods of class Field are used to
– obtain the type of the field
– get and set the field’s value on objects
36

Field
37
Method Description
getDeclaringClass() Returns the Class object representing the class or interface that
declares the field represented by this Field object.
getModifiers() Returns the Java language modifiers for the field represented by
this Field object, as an integer.
getName() Returns the name of the field represented by this Field object,
as String.
getType() Returns a Class object that identifies the declared type for the
field represented by this Field object.
get(Object obj) Returns the value of the field represented by this Field object,
on the specified object. The value is automatically wrapped in an
object if it has a primitive type.
set(Object obj, Object value) Sets the field represented by this Field object on the specified
object argument to the specified new value. The new value is
automatically unwrapped if the underlying field has a primitive
type.
toString() Returns a String describing this Field.

Constructor
■ A Constructor object represents a reified
constructor
■ Methods of class Constructor are used to
– obtain the formal parameter types of the constructor
– get the checked exception types of the constructor
– create and initialise new instances of the class that
declares the constructor
• provided the class is instantiable
• using the method newInstance
38

Constructor
39
Method Description
getDeclaringClass() Returns the Class object representing the class that declares the
constructor represented by this Constructor object.
getExceptionTypes() Returns an array of Class objects that represent the types of of
exceptions declared to be thrown by the underlying constructor
represented by this Constructor object.
getModifiers() Returns the Java language modifiers for the constructor
represented by this Constructor object, as an integer.
getName() Returns the name of this constructor, as a string.
getParameterTypes() Returns an array of Class objects that represent the formal
parameter types, in declaration order, of the constructor
represented by this Constructor object.
newInstance(Object[] initargs) Uses the constructor represented by this Constructor object to
create and initialize a new instance of the constructor's declaring
class, with the specified initialization parameters.
toString() Returns a String describing this Constructor.

Method
■ A Method object represents a reified method
– may be an abstract method, an instance method or a class
(static) method
■ Methods of class Method are used to
– obtain the formal parameter types of the method
– obtain its return type
– get the checked exception types of the method
– invoke the method on target objects
• instance and abstract method invocation uses dynamic
method resolution
– based on target object’s run-time class
• static method invocation uses the static method of the
method’s declaring class
40

Method
41
Understanding method objects 15
metaobjects that represent methods. Table 1.3 shows some of the methods sup-
Table 1.3 Methods defined by Method
Method Description
Class getDeclaringClass() Returns the Class object that declared the method repre-
sented by this Method object
Class[] getExceptionTypes() Returns an array of Class objects representing the types of
the exceptions declared to be thrown by the method repre-
sented by this Method object
int getModifiers() Returns the modifiers for the method represented by this
Method object encoded as an int
String getName() Returns the name of the method represented by this Method
object
Class[] getParameterTypes() Returns an array of Class objects representing the formal
parameters in the order in which they were declared
Class getReturnType() Returns the Class object representing the type returned by
the method represented by this Method object
Object invoke(Object obj, Object[] args) Invokes the method represented by this Method object on
the specified object with the arguments specified in the
Object array

– Class
42

Reflection in Java.
Java Reflection API (Package java.lang.reflect)
Call Stack Introspection.
Introduction.
The Java’s Class Model.
Java’s Limitations on Reflection.
Classes and Interfaces for Reflection.
Since Java 1.2
– java.lang.Object
– java.lang.Class
– java.lang.reflect.Member
– java.lang.reflect.Field (Member)
– java.lang.reflect.Method (Member)
– java.lang.reflect.Constructor (Member)
– boolean.class, char.class, int.class, double.class, ...
Java 1.0
Class
Object
Java 1.1
Field
Method
Constructor
Java 1.2
AccessibleObject
ReflectPermission
History of
Reflection in Java
43
Object
Class Point
Field
Method
Constructor
Member

Introduction.
Since Java 1.2
– java.lang.Class
Java 1.0
Class
Object
Java 1.1
Field
Method
Constructor
Java 1.2
AccessibleObject
ReﬂectPermission
History of
Reflection in Java
44

Reflective features since 1.2
■ AccessibleObject
– base class for Field, Method and Constructor objects
– setting the accessible flag in a reflected object suppresses default
Java language access control checks when it is used
• permits sophisticated applications with sufficient privilege, such as Java
Object Serialization or other persistence mechanisms, to manipulate
reflected objects in a manner that would normally be prohibited
■ ReflectPermission
– is the security permission class for reflective operations
– defines the suppressAccessChecks permission name which allows
suppressing the standard Java language access checks (for public,
default (package) access, protected, and private members)
performed by reflected objects at their point of use
45

Introduction.
Since Java 1.3
– java.lang.Class
– java.lang.reflect.AccessibleObject
– java.lang.reflect.Proxy
– java.lang.reflect.InvocationHandler
Java 1.0
Class
Object
Java 1.1
Field
Method
Constructor
Java 1.2
AccessibleObject
ReﬂectPermission
Java 1.3
Proxy
InvocationHandler
History of
Reflection in Java
46

■ Proxy (class)
– provides static methods for creating dynamic proxy
classes and instances
– is superclass of all dynamic proxy classes created by
those methods
■ InvocationHandler (interface)
– is the interface implemented by the invocation handler of
a proxy instance
– each proxy instance has an associated invocation handler
– when a method is invoked on a proxy instance, the
method invocation is encoded and dispatched to the
invoke method of its invocation handler
47

Introduction.
Since Java 1.5
– java.lang.Class
– java.lang.reflect.AccessibleObject
– java.lang.reflect.Proxy
– java.lang.reflect.InvocationHandler
– java.lang.annotation.Annotation
– java.lang.instrument.Instrumentation
Java 1.0
Class
Object
Java 1.1
Field
Method
Constructor
Java 1.2
AccessibleObject
ReﬂectPermission
Java 1.3
Proxy
InvocationHandler
Java 1.4 Java 1.5
Annotation
Instrumentation
History of
Reflection in Java
48

■ Annotation
– Java 1.5 supports annotating Java programs with custom annotations
– Annotations can be accessed at compile-time and at run-time
– E.g., annotate some methods with @prelog annotation and check for this
annotation to print a log message before execution of those methods
■ Instrumentation
– java.lang.instrument provides services that allow Java programming agents to
instrument programs running on the JVM
– The instrumentation mechanism is modification of the byte-codes of
methods.
■ Type
– reflection API of Java 1.5 was extended to deal with new Java 1.5 types
• generic arrays, parameterized types, type variables, ...
– Type is the common superinterface for all Java types
• several subinterfaces for the new Java 1.5 types 49

Basics of reflection in java

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Basics of reflection in java (20)

More from kim.mens (20)

Recently uploaded (20)

Basics of reflection in java