Detecting Class Innards in Groovy

When using a new language or using new features of a language that I have not used before, I like to know what fields and methods are supported by various classes and objects in that language. This has certainly been the case as I have learned and used Groovy. In this post, I look at the many ways one can find out what a Groovy class/object has to offer.


Javadoc API Documentation

One of the things I have always liked about Java is the ready availability of its standard API documentation. Fortunately, Groovy's GDK extensions and the Groovy distribution classes are similarly well documented. I find myself frequently using these generated HTML pages to discover new APIs that are available to me in the standard Groovy distribution.


Object.toString()

Groovy inherits positive Java features including the ability for object's to easily provide their state via a standard approach by explicitly overriding Object.toString(). This is a valuable tactic in Java (see Item 9 in Effective Java) and continues to be valuable in Groovy. The most significant downside of the toString() approach is that its value relies completely on the author of the class. There are several things a developer can do to make more effective toString() methods, but there's no guarantee any of those things have been done.

In fact, there's no guarantee that a toString() metho for a given class whose instance is being used even provides an explicit overridden toString() method. The next code listing is of a simple Groovy class that fails to explicitly override toString().

/**
 * Simple Groovy class used in demonstration of Groovy detecting methods without
 * explicitly overridden inspect() method, toString() method, or dump() method.
 *
 * @author Dustin
 */
class Person
{
   String lastName

   String firstName

   Person(final String newLastName, final String newFirstName)
   {
      this.lastName = newLastName
      this.firstName = newFirstName
   }
}

When an instance of this simple Groovy class has it's toString() invoked (whether implicitly or explicitly), the output is the same as for a Java class with no explicit toString() (and as defined by Object.toString() Javadoc). It will look something like this:

Person@149eb9f

Object.inspect()

Groovy's GDK Object class specifies an inspect() method for which the Javadoc states: "Inspects returns the String that matches what would be typed into a terminal to create this object." I rarely find this method very useful, but do cover it briefly here.

The inspect() method is often not implemented. When this is the case, the same object's toString() method is invoked. If the object's toString() method is not explicitly implemented, Java's Object.toString() is invoked.

This is demonstrated in the next screen snapshots for the Java Date class and for the Groovy AntBuilder class (the latter of which does not have an explicit inspect() or an explicit toString() implementation).

The Groovy Object.inspect() method suffers the same weakness as Java's (and Groovy's) Object.toString(): the method is only as good as what the author of the class implemented (which might be nothing). In the worst case, an author might not have overridden the inspect() method or the toString() method (as was the case for AntBuilder in the example above) and then very little information is provided.

The next code listing is for a simple Groovy class that implements toString() but fails to implement inspect().

PersonWithToString.groovy

/**
 * Simple Groovy class used in demonstration of Groovy detecting methods without
 * explicitly overridden inspect() method, but with an explicitly overridden
 * toString() method.
 *
 * @author Dustin
 */
class PersonWithToString
{
   String lastName

   String firstName

   PersonWithToString(final String newLastName, final String newFirstName)
   {
      this.lastName = newLastName
      this.firstName = newFirstName
   }

   @Override
   String toString()
   {
      return this.firstName + " " + this.lastName;
   }
}

If the above class is instantiated, it will return the same String whether toString() is explicitly or implicitly called or if inspect() is called. For example, suppose the class is instantiated and invoked as shown in the next code listing.

def person2 = new PersonWithToString("Rubble", "Barney")
doToString(person2)
doInspect(person2)

def doToString(obj)
{
   println "toString(): ${obj}\n"
}

def doInspect(obj)
{
   // Inspect
   println "inspect(): ${obj.inspect()}\n"
}

The output when the above is executed looks like this:

toString(): Barney Rubble

inspect(): Barney Rubble

We can explicitly override inspect() to make it useful and to meet its advertised reason for existence. An example of how this might be done is demonstrated in the next code listing.

PersonWithInspect.groovy

/**
 * Simple Groovy class used in demonstration of Groovy detecting methods with
 * explicitly overridden inspect() method but without explicitly overridden
 * dump() method.
 *
 * @author Dustin
 */
class PersonWithInspect
{
   String lastName

   String firstName

   PersonWithInspect(final String newLastName, final String newFirstName)
   {
      this.lastName = newLastName
      this.firstName = newFirstName
   }

   @Override
   String toString()
   {
      return this.firstName + " " + this.lastName
   }

   @Override
   String inspect()
   {
      return "new Person(" + this.lastName + ", " + this.firstName + ")"
   }
}

When this code has its toString() and inspect() methods called similarly to how the last Groovy class's methods were called, the output is now different:

toString(): Barney Rubble

inspect(): new Person(Rubble, Barney)

Overriding the inspect() method made it more useful and made it so that it not only provides more/different information than already available via toString(), but also helped it achieve the declared (in comments) reason for its existence: to "return the String that matches what would be typed into a terminal to create this object."


Object.dump()

The Object.dump() method often provides more details than Object.inspect(). Its Javadoc documentation states about this method: "Generates a detailed dump string of an object showing its class, hashCode and fields."

The next screen snapshot shows what the dump method displays for a new Java Date instance.

The next screen snapshot shows the AntBuilder.dump() results, which are far more descriptive than the AntBuilder.inspect() method provided.

The Object.dump() method works even when the class whose instance it is being invoked against has not even overridden the dump method. For example, suppose that the Groovy class PersonWithInspect used above had dump() called against it. Even though that class never explicitly defines such a method, calling it leads to results like this:

<PersonWithInspect@1bbd7b2 lastName=Rubble firstName=Barney>

Although no dump() method was explicitly written, calling dump() worked and returned the name of the class with its hash code and with its two attributes (lastName and firstName).

A significant advantage of Groovy's Object.dump() is that it does provide more details about an object's current state without the class author implementing or overriding any specific methods. A Groovy developer is still free to override dump() if so desired, but this is probably rarely needed or even recommended because the existing dump() method is a reasonable implementation.

The next code listing provides a simple Groovy class in which the author has chosen (perhaps poorly) to explicitly override Object.dump().

PersonWithDump.groovy

/**
 * Simple Groovy class used in demonstration of Groovy detecting methods with
 * explicitly overridden dump() method. This is typically not necessary or even
 * desirable as the dump() method is standardly supported.
 *
 * @author Dustin
 */
class PersonWithDump
{
   String lastName

   String firstName

   PersonWithDump(final String newLastName, final String newFirstName)
   {
      this.lastName = newLastName
      this.firstName = newFirstName
   }

   @Override
   String toString()
   {
      return this.firstName + " " + this.lastName
   }

   @Override
   String inspect()
   {
      return "new Person(" + this.lastName + ", " + this.firstName + ")"
   }

   @Override
   String dump()
   {
      return toString()
   }
}

When an instantiation of the above Groovy class has its toString(), inspect(), and dump() methods called, the output appears as follows.

toString(): Barney Rubble

inspect(): new Person(Rubble, Barney)

dump(): Barney Rubble

The above example demonstrates that dump() can be overridden if desired. In this exmaple, it was overridden to simply provide the result of the toString(), which is obviously less information than the default dump() implementation provides.

Before leaving discussion of the Groovy's dump() method, one might ask oneself, "How, or even does, it work for instances of Java classes used in a Groovy context?" That's a great question. The answer to it begins with the next code listing, which shows a small piece of code that instantiates a Java String, queries it for its class and attempts to dump its contents.

def string = "Dustin was here."
println string.class
doDump(string)

def doDump(obj)
{
   println "dump(): ${obj.dump()}\n"
}

The output when the above code is executed is shown next.

class java.lang.String
dump(): <java.lang.String@796944de value=Dustin was here. offset=0 count=16 hash=2036942046>

Nice! Even the instantiated class, which is unsurprisingly treated as a Java String, has support for the Groovy-provided dump() method. That is the beauty or black magic of Groovy's dynamic metadata support in action.


Direct Reflection

So far, I've looked at detection of what a particular Groovy class has to offer via some ways that are standard to Java as well (Javadoc documentation and Object.toString()) and
have also looked at two approaches that are specific to Groovy (Object.inspect() and Object.dump()). Another way to inspect a particular object in Groovy is to use Java's reflection capabilities. Groovy makes it a little easier to use Java's reflection capabilities directly. This is a powerful technique that can require more effort than some of the other approaches, but can be used programatically and can be used to find a plethora of details about a given object's underlying class, method, and attribute structure.

The next code listing demonstrates access of a Groovy class's name, methods names, and fields names via direct Java reflection on the instance of class PersonWithDump shown above.

def doReflection(obj)
{
   println("Reflection:")
   println "\tClass Name: ${obj.class.name}"
   def methods = obj.class.declaredMethods
   def methodsNames = new StringBuilder()
   methods.each
   {
      methodsNames << it.name << " "
   }
   println "\tMethods Names: ${methodsNames}"
   def fields = obj.class.declaredFields
   def fieldsNames = new StringBuilder()
   fields.each
   {
      fieldsNames << it.name << " "
   }
   println "\tFields Names: ${fieldsNames}"
}

When the above reflection-based code is executed against an instance of PersonWithDump, the output appears as shown next.

Reflection:
 Class Name: PersonWithDump
 Methods Names: invokeMethod getMetaClass setMetaClass inspect $getCallSiteArray $createCallSiteArray class$ $getStaticMetaClass $get$$class$groovy$lang$MetaClass this$dist$invoke$2 $get$$class$java$lang$String this$dist$set$2 this$dist$get$2 super$1$wait super$1$wait super$1$wait super$1$toString super$1$notify super$1$notifyAll super$1$getClass super$1$equals super$1$clone super$1$hashCode super$1$finalize getLastName setLastName getFirstName setFirstName $get$$class$PersonWithDump setProperty getProperty toString dump 
 Fields Names: lastName firstName $staticClassInfo metaClass __timeStamp __timeStamp__239_neverHappen1295139333183 $callSiteArray $class$groovy$lang$MetaClass $class$java$lang$String $class$PersonWithDump 

This example has shown that reflection can be easily applied directly in Groovy as it is applied in Java. In fact, Groovy's use of Java reflection even supports the identification of internal Groovy-only metadata methods and fields.


Object.getProperties()

Groovy offers an additional convenience method for determining information on a Groovy class's properties. The output shown next is what one can expect to see when an instance has its getProperties() method called either by calling the method explicitly or using Groovy's syntactic sugar to access it simply with .properties.

[class:class PersonWithDump, firstName:Barney, lastName:Rubble, metaClass:org.codehaus.groovy.runtime.HandleMetaClass@14dd758[groovy.lang.MetaClassImpl@14dd758[class PersonWithDump]]]

Note that no getProperties() method was explicitly provided in the PersonWithDump class, but calling person4.properties still leads to the properties information being made available in name/value pairs. Like Object.dump(), Object.getProperties() provides useful details without needing to specifically implement/override that method.

Does this nice Groovy getProperties() approach work for Java classes used in Groovy? To find out, we start with this code listing for a simple Java class called JavaPerson.

JavaPerson.java

/**
 * Simple Java class with no set methods for its data members.
 *
 * @author Dustin
 */
public class JavaPerson
{
   private final String lastName;

   private final String firstName;

   public JavaPerson(final String newLastName, final String newFirstName)
   {
      this.lastName = newLastName;
      this.firstName = newFirstName;
   }

   public String getLastName()
   {
      return this.lastName;
   }

   public String getFirstName()
   {
      return this.firstName;
   }
}

The Java class just shown does not have an explicitly overridden toString() method. Because it's not Groovy, it doesn't override inspect() either. Of course, it is not typical to override Object.dump() or Object.getProperties() in Groovy classes, so it is really not surprising that this Java class does not override those either. Now, let's suppose that some simple Groovy code invoked these methods on an instance of the Java class JavaPerson. This might look like the code shown in the next code listing.

def person5 = new JavaPerson("Rubble", "Barney")
doToString(person5)
doInspect(person5)
doReflection(person5)
doDump(person5)
doProperties(person5)

// The methods shown above with names starting with "do" have
// been defined in previous code listings in this post, but
// doProperties is first shown here.

def doProperties(obj)
{
   println ".properties: ${obj.properties}"
}

When the code is executed in Groovy, the results on the instance of the Java class are as shown next.

toString(): JavaPerson@18622f3

inspect(): JavaPerson@18622f3

dump(): <JavaPerson@18622f3 lastName=Rubble firstName=Barney>

Reflection:
 Class Name: JavaPerson
 Methods Names: getLastName getFirstName 
 Fields Names: lastName firstName 
dump(): &lr;JavaPerson@18622f3 lastName=Rubble firstName=Barney>

.properties: [class:class JavaPerson, firstName:Barney, lastName:Rubble]

As expected, toString() and inspect() are not very interesting or useful because neither is implemented/overridden. However, dump() and .properties (Groovy approaches) are useful. Not surprisingly, reflection is useful on the Java class as well.


javap

I have blogged before on the utility of the javap tool provided with the HotSpot SDK. It is easy to compile a Groovy class or script to a .class file explicitly with the groovyc command and then javap can be applied against that generated .class file.

The next screen snapshot demonstrates compiling the PersonWithInspect Groovy class shown above with groovyc and then running javap against the generated PersonWithInspect.class file.

There are numerous methods in the output that were not explicitly part of the class's definition. This javap output is a nice mechanism for peeking into the methods the Groovy class provides and the types of parameters each method expects.

As an interesting side note here, let's look at what the javap output looks like for a Java class compiled via traditional javac as compared to the javap output for a Java class compiled via groovyc. To illustrate this, the pure Java JavaPerson class will be compiled both with javac (Java compiling) and with groovyc (Groovy/Java combination compilation). The output from running the javap tool against each generated .class file is then displayed in the screen snapshots.

javap Output for javac-Generated JavaPerson

javap Output for groovyc-Generated JavaPerson

The two images just shown demonstrate quite different output. The output from javap for the javac-compiled Java class shows the methods we expected: a constructor and two "get" methods for the two attributes. We can also see that the class simply extends the Java Object class that is extended directly or indirectly by all Java classes. The output from the groovyc-compiled Java class shows that it not only extends Object, but that it also implements the groovy.lang.GroovyObject interface. We can also observe that there are many more methods available in the version compiled with groovyc, including the automatically added "set" methods and the "meta" infrastructure methods added by Groovy.


groovy.inspect.Inspector

Groovy makes its introspection capabilities accessible via a single interface encapsulated within the groovy.inspect.Inspector class. The following code snippet shows how this handy class might be used to easily access data about a particular object (whichever object is accepted in the method call under the name 'obj').

def doInspector(obj)
{
   def inspector = new groovy.inspect.Inspector(obj)
   def inspectorReport = new StringBuilder()
   inspectorReport <<<< "Object under inspection "
   inspectorReport <<<< (inspector.isGroovy() ? "IS" : "is NOT") <<<< " Groovy!\n"
   inspectorReport <<<< "METHODS\n"
   def methods = inspector.methods
   methods.each
   {
      inspectorReport <<<< "\t" <<<< it.toString() <<<< "\n"
   }
   inspectorReport <<<< "\nMETA METHODS\n"
   def metaMethods = inspector.metaMethods
   metaMethods.each
   {
      inspectorReport <<<< "\t" <<<< it.toString() <<<< "\n"
   }
   inspectorReport <<<< "\nPROPERTY INFO\n"
   def properties = inspector.propertyInfo
   properties.each
   {
      inspectorReport <<<< "\t" <<<< it.toString() <<<< "\n"
   }
   println inspectorReport
}

If the above code is invoked and an instance of PersonWithInspect is passed to it, the output looks like the following:

Object under inspection IS Groovy!
METHODS
 [JAVA, public, PersonWithInspect, Object, invokeMethod, String, Object, ]
 [JAVA, public, PersonWithInspect, MetaClass, getMetaClass, , ]
 [JAVA, public, PersonWithInspect, void, setMetaClass, MetaClass, ]
 [JAVA, public, PersonWithInspect, String, inspect, , ]
 [JAVA, public, PersonWithInspect, Object, this$dist$invoke$2, String, Object, ]
 [JAVA, public, PersonWithInspect, void, this$dist$set$2, String, Object, ]
 [JAVA, public, PersonWithInspect, Object, this$dist$get$2, String, ]
 [JAVA, public, PersonWithInspect, void, super$1$wait, long, int, ]
 [JAVA, public, PersonWithInspect, void, super$1$wait, long, ]
 [JAVA, public, PersonWithInspect, void, super$1$wait, , ]
 [JAVA, public, PersonWithInspect, String, super$1$toString, , ]
 [JAVA, public, PersonWithInspect, void, super$1$notify, , ]
 [JAVA, public, PersonWithInspect, void, super$1$notifyAll, , ]
 [JAVA, public, PersonWithInspect, Class, super$1$getClass, , ]
 [JAVA, public, PersonWithInspect, boolean, super$1$equals, Object, ]
 [JAVA, public, PersonWithInspect, Object, super$1$clone, , ]
 [JAVA, public, PersonWithInspect, int, super$1$hashCode, , ]
 [JAVA, public, PersonWithInspect, void, super$1$finalize, , ]
 [JAVA, public, PersonWithInspect, String, getLastName, , ]
 [JAVA, public, PersonWithInspect, void, setLastName, String, ]
 [JAVA, public, PersonWithInspect, String, getFirstName, , ]
 [JAVA, public, PersonWithInspect, void, setFirstName, String, ]
 [JAVA, public, PersonWithInspect, void, setProperty, String, Object, ]
 [JAVA, public, PersonWithInspect, Object, getProperty, String, ]
 [JAVA, public, PersonWithInspect, String, toString, , ]
 [JAVA, public final native, Object, void, wait, long, InterruptedException]
 [JAVA, public final, Object, void, wait, , InterruptedException]
 [JAVA, public final, Object, void, wait, long, int, InterruptedException]
 [JAVA, public, Object, boolean, equals, Object, ]
 [JAVA, public native, Object, int, hashCode, , ]
 [JAVA, public final native, Object, Class, getClass, , ]
 [JAVA, public final native, Object, void, notify, , ]
 [JAVA, public final native, Object, void, notifyAll, , ]
 [JAVA, public, PersonWithInspect, PersonWithInspect, PersonWithInspect, String, String, ]

META METHODS
 [GROOVY, public, Object, Collection, collect, Collection, Closure, n/a]
 [GROOVY, public, Object, List, getMetaPropertyValues, , n/a]
 [GROOVY, public, Object, Object, eachWithIndex, Closure, n/a]
 [GROOVY, public, Object, void, print, PrintWriter, n/a]
 [GROOVY, public, Object, void, addShutdownHook, Closure, n/a]
 [GROOVY, public, Object, Iterator, iterator, , n/a]
 [GROOVY, public static, Object, void, sleep, long, n/a]
 [GROOVY, public, Object, Object, inject, Object, Closure, n/a]
 [GROOVY, public, Object, int, findLastIndexOf, Closure, n/a]
 [GROOVY, public, Object, void, setMetaClass, MetaClass, n/a]
 [GROOVY, public, Object, boolean, any, Closure, n/a]
 [GROOVY, public, Object, Object, use, [Ljava.lang.Object;, n/a]
 [GROOVY, public, Object, boolean, every, , n/a]
 [GROOVY, public, Object, void, println, PrintWriter, n/a]
 [GROOVY, public, Object, MetaClass, getMetaClass, , n/a]
 [GROOVY, public, Object, Collection, split, Closure, n/a]
 [GROOVY, public, Object, Collection, findAll, Closure, n/a]
 [GROOVY, public, Object, List, findIndexValues, Number, Closure, n/a]
 [GROOVY, public, Object, void, printf, String, Object, n/a]
 [GROOVY, public, Object, MetaProperty, hasProperty, String, n/a]
 [GROOVY, public, Object, Object, asType, Class, n/a]
 [GROOVY, public, Object, String, sprintf, String, Object, n/a]
 [GROOVY, public, Object, Object, getAt, String, n/a]
 [GROOVY, public, Object, List, collect, Closure, n/a]
 [GROOVY, public, Object, boolean, every, Closure, n/a]
 [GROOVY, public, Object, Collection, grep, Object, n/a]
 [GROOVY, public, Object, String, dump, , n/a]
 [GROOVY, public, Object, int, findIndexOf, int, Closure, n/a]
 [GROOVY, public, Object, Object, use, Class, Closure, n/a]
 [GROOVY, public, Object, Object, identity, Closure, n/a]
 [GROOVY, public, Object, Map, getProperties, , n/a]
 [GROOVY, public, Object, void, println, , n/a]
 [GROOVY, public, Object, Object, invokeMethod, String, Object, n/a]
 [GROOVY, public, Object, List, findIndexValues, Closure, n/a]
 [GROOVY, public, Object, boolean, is, Object, n/a]
 [GROOVY, public, Object, int, findIndexOf, Closure, n/a]
 [GROOVY, public, Object, String, inspect, , n/a]
 [GROOVY, public, Object, boolean, asBoolean, , n/a]
 [GROOVY, public, Object, Object, with, Closure, n/a]
 [GROOVY, public, Object, boolean, any, , n/a]
 [GROOVY, public, Object, void, printf, String, [Ljava.lang.Object;, n/a]
 [GROOVY, public, GroovyObject, MetaClass, getMetaClass, , n/a]
 [GROOVY, public, Object, void, println, Object, n/a]
 [GROOVY, public, Object, MetaClass, metaClass, Closure, n/a]
 [GROOVY, public, Object, List, respondsTo, String, n/a]
 [GROOVY, public, Object, Object, each, Closure, n/a]
 [GROOVY, public, Object, Object, find, Closure, n/a]
 [GROOVY, public, Object, boolean, isCase, Object, n/a]
 [GROOVY, public, Object, void, print, Object, n/a]
 [GROOVY, public, Object, void, putAt, String, Object, n/a]
 [GROOVY, public static, Object, void, sleep, long, Closure, n/a]
 [GROOVY, public, Object, int, findLastIndexOf, int, Closure, n/a]
 [GROOVY, public, Object, String, toString, , n/a]
 [GROOVY, public, Object, Object, use, List, Closure, n/a]
 [GROOVY, public, Object, List, respondsTo, String, [Ljava.lang.Object;, n/a]
 [GROOVY, public, Object, String, sprintf, String, [Ljava.lang.Object;, n/a]

PROPERTY INFO
 [GROOVY, public, n/a, Class, class, class PersonWithInspect]
 [GROOVY, public, n/a, String, firstName, "Barney"]
 [GROOVY, public, n/a, String, lastName, "Rubble"]
 [GROOVY, public, n/a, MetaClass, metaClass, org.codehaus.groovy.runtime.HandleMetaClass@e53220[groovy.lang.MetaClassImpl@e53220[class PersonWithInspect]]]

There is significant data provided by Inspector. The "GROOVY" or "JAVA" portions indicate the origin of the field or method (Groovy or Java source code).

Out of curiosity, what does Inspector report for a Java class compiled with groovyc (or compiled implicitly when accessed by a Groovy script)? The following output shows what Inspector reports (including the fact that the underlying class is NOT Groovy, though there are Groovy methods added).

Object under inspection is NOT Groovy!
METHODS
 [JAVA, public, JavaPerson, String, getLastName, , ]
 [JAVA, public, JavaPerson, String, getFirstName, , ]
 [JAVA, public final native, Object, void, wait, long, InterruptedException]
 [JAVA, public final, Object, void, wait, , InterruptedException]
 [JAVA, public final, Object, void, wait, long, int, InterruptedException]
 [JAVA, public, Object, boolean, equals, Object, ]
 [JAVA, public, Object, String, toString, , ]
 [JAVA, public native, Object, int, hashCode, , ]
 [JAVA, public final native, Object, Class, getClass, , ]
 [JAVA, public final native, Object, void, notify, , ]
 [JAVA, public final native, Object, void, notifyAll, , ]
 [JAVA, public, JavaPerson, JavaPerson, JavaPerson, String, String, ]

META METHODS
 [GROOVY, public, Object, List, collect, Closure, n/a]
 [GROOVY, public, Object, Map, getProperties, , n/a]
 [GROOVY, public, Object, boolean, every, , n/a]
 [GROOVY, public, Object, void, print, Object, n/a]
 [GROOVY, public, Object, boolean, any, , n/a]
 [GROOVY, public, Object, MetaClass, metaClass, Closure, n/a]
 [GROOVY, public static, Object, void, sleep, long, Closure, n/a]
 [GROOVY, public, Object, String, inspect, , n/a]
 [GROOVY, public, Object, int, findLastIndexOf, int, Closure, n/a]
 [GROOVY, public, Object, Collection, split, Closure, n/a]
 [GROOVY, public, Object, boolean, asBoolean, , n/a]
 [GROOVY, public, Object, Object, use, Class, Closure, n/a]
 [GROOVY, public, Object, boolean, every, Closure, n/a]
 [GROOVY, public, Object, void, println, Object, n/a]
 [GROOVY, public, Object, List, getMetaPropertyValues, , n/a]
 [GROOVY, public, Object, String, sprintf, String, [Ljava.lang.Object;, n/a]
 [GROOVY, public, Object, int, findIndexOf, Closure, n/a]
 [GROOVY, public, Object, int, findLastIndexOf, Closure, n/a]
 [GROOVY, public, Object, void, println, , n/a]
 [GROOVY, public, Object, Object, identity, Closure, n/a]
 [GROOVY, public, Object, Collection, collect, Collection, Closure, n/a]
 [GROOVY, public, Object, String, toString, , n/a]
 [GROOVY, public, Object, MetaClass, getMetaClass, , n/a]
 [GROOVY, public, Object, String, dump, , n/a]
 [GROOVY, public, Object, Object, find, Closure, n/a]
 [GROOVY, public, Object, Object, each, Closure, n/a]
 [GROOVY, public, Object, MetaProperty, hasProperty, String, n/a]
 [GROOVY, public, Object, List, findIndexValues, Closure, n/a]
 [GROOVY, public, Object, Object, use, List, Closure, n/a]
 [GROOVY, public, Object, Object, inject, Object, Closure, n/a]
 [GROOVY, public, Object, Collection, grep, Object, n/a]
 [GROOVY, public, Object, void, println, PrintWriter, n/a]
 [GROOVY, public, Object, boolean, is, Object, n/a]
 [GROOVY, public, Object, List, findIndexValues, Number, Closure, n/a]
 [GROOVY, public, Object, boolean, isCase, Object, n/a]
 [GROOVY, public, Object, int, findIndexOf, int, Closure, n/a]
 [GROOVY, public, Object, Object, invokeMethod, String, Object, n/a]
 [GROOVY, public, Object, Object, asType, Class, n/a]
 [GROOVY, public static, Object, void, sleep, long, n/a]
 [GROOVY, public, Object, boolean, any, Closure, n/a]
 [GROOVY, public, Object, void, addShutdownHook, Closure, n/a]
 [GROOVY, public, Object, void, printf, String, Object, n/a]
 [GROOVY, public, Object, void, putAt, String, Object, n/a]
 [GROOVY, public, Object, void, print, PrintWriter, n/a]
 [GROOVY, public, Object, List, respondsTo, String, [Ljava.lang.Object;, n/a]
 [GROOVY, public, Object, Object, eachWithIndex, Closure, n/a]
 [GROOVY, public, Object, Collection, findAll, Closure, n/a]
 [GROOVY, public, Object, Iterator, iterator, , n/a]
 [GROOVY, public, Object, void, printf, String, [Ljava.lang.Object;, n/a]
 [GROOVY, public, Object, List, respondsTo, String, n/a]
 [GROOVY, public, Object, Object, getAt, String, n/a]
 [GROOVY, public, Object, Object, use, [Ljava.lang.Object;, n/a]
 [GROOVY, public, Object, Object, with, Closure, n/a]
 [GROOVY, public, Object, void, setMetaClass, MetaClass, n/a]
 [GROOVY, public, Object, String, sprintf, String, Object, n/a]

PROPERTY INFO
 [GROOVY, public, n/a, Class, class, class JavaPerson]
 [GROOVY, public, n/a, String, firstName, "Barney"]
 [GROOVY, public, n/a, String, lastName, "Rubble"]

ObjectBrowser

In this post, I have looked at general Java techniques (Javadoc, Object.toString(), javap) for peeking inside of Groovy objects as well as Groovy-specific approaches. I have saved an extremely useful Groovy-specific approach for last. The Groovy graphical-based ObjectBrowser is a user-friendly approach for seeing the innards of a Groovy object. It is based on Groovy's many inspection techniques including those already discussed here. In fact, it's Javadoc comments state about it: "A little GUI to show some of the Inspector capabilities." In other words, ObjectBrowser provides graphical access to the capabilities provided by groovy.inspect.Inspector.

There is more than one way to access ObjectBrowser. When using Groovy Shell, for example, one can type the "inspect" command to invoke ObjectBrowser. This is demonstrated in the next screen snapshot.

The ObjectBrowser can be invoked outside of the Groovy Shell as well. For example, the ObjectBrowser GUI is automatically started when groovy.inspect.swingui.ObjectBrowser.inspect(obj) is invoked within Groovy code (and obj is the name of the object to be evaluated).

As shown in the image above, the Groovy Object Browser provides details of the public fields and methods as well as the Groovy meta methods. It shows the name, current value, data type, modifier, and declarer for each. It also supplies the origin (Groovy or Java) of each. Advantages of this approach includes its being graphical in nature and easy to use as well as the breadth of information (including current values) that it provides.


Integrated Development Environments

Integrated Development Environments (IDEs) have lagged behind in their support for dynamic languages as compared to their support for static languages. That being stated, IDEs continue to offer improved support and plug-ins for Groovy and can be useful in determining details of what a Groovy class has to offer.


Conclusion

I have discussed and demonstrated several different Groovy-specific and Java-general approaches for determining characteristics of a Groovy object. These approaches overlap (and some even make sure of each other) and have their own advantages and disadvantages. There is no shortage of approaches for learning more about the characteristics of a given Groovy object, so which is best to use often depends on the particular situation and the developer's needs.


Further Reading

⇒ Groovy Introspection: Know What You Have

⇒ Groovy Goodness: Getting Information about Objects

⇒ Difference Between inspect() and dump()

⇒ Background on dump() and inspect()

⇒ Groovy inspect()/Eval for Externalizing Data