CSC/ECE 517 Summer 2008/wiki1 3 aobk
Reflection in Ruby and Java
- What is Reflection?
- Reflection, is the realm of Computer Science, it is the process of introspection by a program.Reflection allows program entities to discover things about themselves through introspection.Through the technique of metaprogramming, aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime.
By looking at and inside classes and objects, much can be discovered, including the following:
- what objects are contained in a program
- the class hierarchy
- the attributes and methods of the objects contained in the program
- various method information
One of the design challenges of using Reflection is that you need to clarify what services you wish to provide at runtime that don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution though, over-reliance on Reflection can lead to performance issues because of the extra overhead of determining what class(es) need to be loaded.
Java Reflection Sequences
- Reflection in Java
- Java uses a Reflection API to inspect and manipulate itself. It includes the expanded class class in java.lang and the java.lang.reflect package, which represents the members of a class with Method, Constructor and Field objects.Reflection can be used to obtain information about a class and its members.
Example:
- This example uses the Class.forName() method to dynamically load the named class, and then calls various methods of the class object to look up the Superclass, Interfaces, and Members of the class. The example uses Constructor, Field and Method objects to obtain information about each member of the class.
import java.lang.reflect.*;
/** A program that displays a class synopsis for the named class */
public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}
/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());
// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}
System.out.println(" {"); // Begin class member listing.
// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);
System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);
System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);
System.out.println("}"); // End class member listing.
}
/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}
/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}
/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}
/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}
System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
This code is then compiled and run, with the below simple test class pass in:
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
The output generated is as follows:
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
Ruby Reflection Sequences
The Java code above, which displays constructors, methods, and other information pertinent to the testInput class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
- mod.private_instance_methods(inc_super=true)
- mod.protected_instance_methods(inc_super=true)
- mod.public_instance_methods(inc_super=true)
- mod.singleton_methods(inc_super=true)
For example, using the Demo class below, all class methods can be easily displayed.
irb(main):001:0> class Demo irb(main):002:1> public irb(main):003:1> def method1 irb(main):004:2> end irb(main):005:1> private irb(main):006:1> def method2 irb(main):007:2> end irb(main):008:1> public irb(main):009:1> def method3 irb(main):010:2> end irb(main):011:1> protected irb(main):012:1> def method4 irb(main):013:2> end irb(main):014:1> def Demo.method5 irb(main):015:2> end irb(main):016:1> public irb(main):017:1> def method6 irb(main):018:2> end irb(main):019:1> end => nil irb(main):020:0> Demo.private_instance_methods(false) => ["method2"] irb(main):021:0> Demo.protected_instance_methods(false) => ["method4"] irb(main):022:0> Demo.public_instance_methods(false) => ["method3", "method6", "method1"] irb(main):023:0> Demo.singleton_methods(false) => ["method5"]
Ruby Reflection vs. Java Reflection
- Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as NoSuchMethodError and InvocationTargetException tend to create further complications and confusion when using Java's reflection API.
- Reflection API in java is also used in Database Access with SQL.