Java: Reflection, javap

Hello,

In this article, I want present you the concept of reflection, especially in JAVA world.

First, what is Reflection?
In computer programming, reflection is the ability of a program to review and possibly modify, the internal structures of high-level (eg objects) at runtime.

In OO programming, the reflection allows the introspection of classes i.e. loading a class, creation of an instance and access to the members (static or not), for example the methods’ calls, reading and writing of attributes without knowing the class in advance. Java has an API for reflection which is used mainly to manage extensions/plugins in an application.

I invite you to read the Wikipedia definition http://en.wikipedia.org/wiki/Reflection_(computer_programming).

Use of Reflection
While at first glance, the reflection appears to be reserved for a top-flight programming, but what are the cases of application of reflection?
Following, some concret use cases of reflection:

• Use reflection to discovery of attributs of a object, to initialize its member variables or instanciate an object from its “definition” at runtime. For example, Spring framework whose the success demonstrates the viability of reflection in this use case.
• Use reflection to write a generic code generator for a set of classes (like JAXB-XJC).
• Automatically process the content objects. For example, to display all informations of an object in a page automatically (ie without access to all fields of the object), the use of reflection can be very handy and save a lot time. Indeed, by browsing the contents of an object by reflection, in a nutshell, any structural modification of the object (such as adding a field in the object) is automatically passed effortlessly to all points using this object.
• The JVM uses reflection to introspect a class of a external library and in error cases, returns with precision a error message allowing its location in code source. For example, a missing method:
  view source

  print?

  1	Java.lang.NoSuchMethodError

  2	At MyOwnClass.main(MyOwnClass.java:123)

• The dynamic programming of reflection allows to ignore the content of classes and write generic code that can handle any class. This type of programming is typically used by IDEs in the aid in programming or code completion without building of a bank of informations concerning the definition of used services.
• Reflection is used in the serialization process in the calls and exchanges on networks.
• …in the development of logging tools, in the SQL script generation for the persistence of an object…etc.

Javap Utility
There are some utilities to make the information available: convert the compiled code (byte code in Java) to a understood language by a human. One such tool is javap, which is available in the SDK and consists of a basic decompiler. In Windows the tools is named Javap.exe, which is present in the directory jdk\bin and its basic syntax is:

For example, below, the description of java.lang.String:

For help:

Implementation of reflection in JAVA
The java.lang.reflect package is devoted to reflection. But the classes java.lang.Class and java.lang.Package are used a lot in the reflection programming. After the compiling of a Java source code, the byte code created contains the meta data including the parent class, implemented interface, constructors, fields, methods,… of compiled code. The characteristics of the object are represented formally by the following main classes:

This list is not exhaustive because the purpose of this article is to give a first approach of reflection. You could find expressly, some examples of reflection API use (where the ‘o’ variable is ‘Object’):

• get the classname of an Object,
  view source

  print?

  1	Class c = o.getClass();

  2	String name = c.getName();

• get the Field Object corresponding to a specific public field,
  view source

  print?

  1	Class c = o.getClass();

  2	Field f = c.getField(name);

• get the public fields of an Object,
  view source

  print?

  1	Class c = o.getClass();

  2	Field[] ftab = c.getFields();

• get a method Object corresponding to a specific public method with the defined parameters by the parameterTypes tables
  view source

  print?

  1	Class c = o.getClass();

  2	Method m = c.getMethod(name, parameterTypes);

• get the public methods of an Object
  view source

  print?

  1	Class c = o.getClass();

  2	Method[] mtab = c.getMethods();

• get a Constructor object corresponding to a specific public constructor with the defined parameters by the parameterTypes table
  view source

  print?

  1	Class c = o.getClass();

  2	Constructor cons = c.getConstructor(parameterTypes);

• get the public Constructors of an Object
  view source

  print?

  1	Class c = o.getClass();

  2	Constructor[] constab = c.getConstructors();

• get the implemented interfaces of an Object
  view source

  print?

  1	Class c = o.getClass();

  2	Class[] itab = c.getInterfaces();

• get the super classes of an Object
  view source

  print?

  1	Class c = o.getClass();

  2	Class superclass = c.getSuperclass();

• get the Package object corresponding of an Object
  view source

  print?

  1	Class c = o.getClass();

  2	Package pck = c.getPackage();

• change the value of a public field
  view source

  print?

  1	Class c = o.getClass();

  2	Field f = c.getField(name);

  3	f.set(o,val);

• return a public field
  view source

  print?

  1	Class c = o.getClass();

  2	Field f = c.getField(name);

  3

  f.get(o);

• Invoke a public method
  view source

  print?

  1	Class c = o.getClass();

  2	Method m = c.getMethod(name, parameterTypes);

  3	m.invoke(o,args);

Reflection and Encapsulation: private, protected, package scopes
So, the methods “getField”, “getFields”, “getMethod” and “getMethods” allow the retrieve the publics fields and methods. However, there are others methods named “getDeclaredFields” and “getDeclaredMethods” which give the possibilities to violate the rules of encapsulation, in being able to see the characteristics of private, protected fields and methods. The Reflection API allows thus, the virtual machine to be able to explore all elements of a class, but especially the necessity to dispose of all meta data in order to detect errors in running.

• get a specific Field object corresponding to public, private or protected field,
  view source

  print?

  1	Class c = o.getClass();

  2	Field f = c.getDeclaredField(name);

  3	f.setAccessible(true);

• get the Public, private and protected fields of an Object,
  view source

  print?

  1	Class c = o.getClass();

  2	Field[] ftab = c.getDeclaredFields();

  3	for (int i = 0; i < ftab.length; i++) {

  4	ftab[i].setAccessible(true);

  5

  }

• get a Method object corresponding to a specific public, private or protected method with the defined parameters by the parameterTypes table,
  view source

  print?

  1	Class c = o.getClass();

  2	Method m = c.getDeclaredMethod(name, parameterTypes);

  3	m.setAccessible(true);

• get the Public, private or protected methods of an Object,
  view source

  print?

  1	Class c = o.getClass();

  2	Method[] mtab = c.getDeclaredMethods();

  3	for (int i = 0; i < mtab.length; i++) {

  4	mtab[i].setAccessible(true);

  5

  }

• get a Constructor object corresponding to public, private or protected constructor with the defined parameters by the parameterTypes table,
  view source

  print?

  1	Class c = o.getClass();

  2	Constructor cons = c.getDeclaredConstructor(parameterTypes);

  3	cons.setAccessible(true);

• get the Public, private or protected constructors of an Object,
  view source

  print?

  1	Class c = o.getClass();

  2	Constructor[] constab = c.getDeclaredConstructors();

  3	for (int i = 0; i < constab.length; i++) {

  4	constab[i].setAccessible(true);

  5

  }

• modify a public, private or protected field,
  view source

  print?

  1	Field f = this.getDeclaredField(o, name);

  2	f.setAccessible(true);

  3	f.set(o,val);

• return a specific public, private or protected field,
  view source

  print?

  1	Field f = this.getDeclaredField(o, name);

  2	f.setAccessible(true);

  3

  f.get(o);

• invoke a specific public, private or protected method,
  view source

  print?

  1	Class[] paramTypes = null;

  2	paramTypes = new Class[args.length];

  3	for(int i=0;i<args.length;++i){

  4	paramTypes[i] = args[i].getClass();

  5

  }

  6	Method m = this.getDeclaredMethod(o, name, paramTypes);

  7	m.setAccessible(true);

  8	m.invoke(o,args);

By calling the setAcessible(true) method on Field or Method objects, the access checks are turned off for the particular Field or Method instance, for reflection only.
So, the access of private, protected or package scoped fields or methods are possible, and even, its value can be modified.

Reflection Tools Class
In order to benefit of above reflection concepts, I propose a tools class:

Download
The attachment java_reflexion.zip contains a project with:
+ TestClassInstance extends SuperTestClassInstance implements Serializable, ITestClassInstance: Class to check via reflection,
+ ITestClassInstance: Interface of class to check via reflection,
+ SuperTestClassInstance: Super class of class to check via reflection,
+ ReflectionTools: ReflectionTools,
+ JUClassToolsWithTestClassInstance: JUNIT testcase to test the reflection,

java_reflexion.zip

Best regards,

Huseyin OZVEREN