Can you use Java Reflection api in GWT client

Question

IS it possible to use the java reflection api in GWT client side? I want to use reflections to find the value of a property on a Javabean. Is this possible?

Answer 1

Since GWT code is translated to Javascript direct usage of reflection API is not supported.

There is a small project GWT-Reflection, that allows to use reflection in GWT.

Answer 2

GWT not support reflection fully, you can see bellow link :

http://www.gwtproject.org/doc/latest/DevGuideCodingBasicsCompatibility.html

You should note the border between java and javascript. In GWT, all code compiles to javascript, so you have to check if JavaScript is a well-defined reflection.

Answer 3

I have made my gwt-reflection library public.

https://github.com/WeTheInternet/xapi/tree/master/gwt/gwt-reflect https://github.com/WeTheInternet/gwt-sandbox/tree/xapi-gwt/user/src/com/google/gwt/reflect

Due to classpath issues with trying to make Gwt pick my version of Class.java over its own, I finally just forked Gwt, added java 8 and reflection support, and now maintain net.wetheinter:gwt-*:2.7.0 which has this support baked in (I will release a 2.8 some time after Gwt 2.8 goes live)

It supports three levels of reflection:

Monolithic:

// Embeds all data needed to perform reflection into hidden fields of class
GwtReflect.magicClass(SomeClass.class);
SomeClass.getField(fieldName).set(null, 1);

Lightweight:

// Allows direct reflection, provided ALL parameters are literals, or traced to literals
SomeClass.class.getField("FIELD_NAME").set(null, 1);

Flyweight:

// Skips creating a Field object entirely, and just invokes the accessor you want
// All params must be literals here as well
GwtReflect.set(SomeClass.class, "FIELD_NAME", null, 1);

These examples also work for Methods and Constructors. There's basic support for annotations, and more to come in the future.

Answer 4

If you just want to use reflection to grab a private field, consider using jsni (javascript native interface) instead; it has no notion of private or public, so you can just grab anything you want like so:

package com.foo;

class SomeClass {
    private String someField;
    private static int someInt;
}

//accessors:
native String ripField(SomeClass from)
/*-{
  return from.@com.foo.SomeClass::someField;
}-*/;
native int ripInt()
/*-{
  return @com.foo.SomeClass::someInt;
}-*/;

Also, I am in the middle of finishing up emulation for java.lang.Class newInstance / reflection.

I'll post back here with a link in about two days if you'd like to play with it.

It requires that you pass a class through a method which I route to a custom generator (like GWT.create, except it returns a generated java.lang.Class with field and method accessors that just point to jsni methods / fields. :)

Answer 5

I've been there and the solution indeed is to use Deferred Binding and Generators. You can see a use of Generators to overcome the lack of Reflection in GWT client here:

http://jpereira.eu/2011/01/30/wheres-my-java-reflection/

Hope it helps.

Answer 6

You can use the GWT Generators functionality that allows you to generate code during the GWT compile phase.

Your bean, that you want to introspect, can extend a class that has a method defined as

public Object getProperty(String propertyName){}

Let's call this class IntrospectionBean.

Let's say that you then have your bean defined as:

public class MyBean extends IntrospectionBean {
    private String prop1;
    private String prop2;
}

The GWT generator will have access to all fields of MyBean and it can generate the getProperty(String propertyName) method during GWT compile time, after iterating through all fields of MyBean.

The generated class might look like this:

public class MyBean extends IntrospectionBean {
    private String prop1;
    private String prop2;

    public Object getProperty(String propertyName) {
        if ("propr1".equals(propertyName)) {
            return prop1;
        }
        if ("propr2".equals(propertyName)) {
            return prop2;
        }

        return null;
    }
}

You could simply then use myBean.getProperty("prop1") in order to retrieve a property based on it's name at runtime.

Here you can find an example of how to implement a gwt generator