CSC/ECE 517 Summer 2008/wiki1 3 aobk

Reflection in Ruby and Java

What is Reflection in computer science?

Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. 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. This provides for a very liberated and dynamic programming environment.

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 when using Reflection is that you need to clarify what services you wish to provide at runtime.

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 following simple test class passed 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 of the class' methods (private, protected, public, and singleton) 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"]

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using Object#send, Method#call, and also various versions of the eval method (including class_eval, module_eval, and instance_eval).

send works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the length method is called on the object, which is a 14 character string.

irb(main):105:0> "This is a test".send(:length)
=> 14

Method objects represent a chunk of code and a context in which it executes. The Method object is created, and it can be executed whenever desired by sending it the call message:

irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12

A third way methods can be invoked dynamically using reflection is with the eval method. eval provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.

irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test  
=> 12

Ruby Reflection vs. Java Reflection

• By coding and comparing we find that 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.
  • In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class. This illustrates Ruby efficiency when looking inside classes.

• Language facilities such as aliasing, reflection, and metaprogramming make Aspect Oriented Programming much easier to perform in Ruby than in Java.

Uses of Reflection

Reflection is used by programs which require the ability to analyze or modify the runtime behavior of applications.This is a relatively advanced feature.Thus, reflection is a powerful technique which can enable applications to perform operations which would otherwise be impossible.

• Extensibility Features:

An application may utilize external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

• Class Browsers and Visual Development Environments

A class browser could enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

• Debuggers and Test Tools

Debuggers could examine private members on classes. Test harnesses could use reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

• Reflection API in java is also used in Database Access with SQL.

Drawbacks of Reflection

Reflection is powerful, but should not be used indiscriminately. It is preferable to avoid using reflection, if possible. The following concerns should be kept in mind when accessing code via reflection:

• Performance Overhead

Certain Java virtual machine optimizations, which greatly increase performance in Java applications, cannot be performed when reflective operations are used due to the dynamically resolved types involved in reflection. Therefore, reflection should be avoided in sections of code called frequently in performance-sensitive applications.

• Security Restrictions

Reflection requires a runtime permission which may not be present when running under a security manager. This is important for code running in a restricted security contect, e.g. in an Applet.

• Exposure of Internals

Operations which would be illegal in a non-reflective environment, such as accessing private fields and methods, are allowed in reflective code. Consequently, unexpected side-effects, which may render code dysfunctional and destroy portability, may result from the use of reflection. Abstractions may also be broken, thus changing behavior with platform upgrades.

References

1. Flanagan, David. Java Examples in a Nutshell. O'Reilly, 2004.
2. Thomas, Dave. Programming Ruby. Raleigh: Pragmatic Bookshelf, 2004.

External Links

• http://phrogz.net/programmingruby/ospace.html
• http://java.sun.com/docs/books/tutorial/reflect/
• http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
• http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html
• http://www.hokstad.com/