public static interface BeanFactory.MetaFactory
BeanFactory reflection mechanism.
Note: While this mechanism continues to work, there is
now an easier way to register classes for reflection, by annotating
them with the BeanFactory.Generate annotation.
In order to use a BeanFactory for a class, you need to
register it by generating a BeanFactory subclass for the
class. You can use BeanFactory.CanvasMetaFactory to scan the
class path and register every Canvas subclass (including your
custom subclasses), or use BeanFactory.FormItemMetaFactory to
regiser every FormItem
subclass. However, if you know that you only need to register some
classes for reflection, then you can use
BeanFactory.MetaFactory instead (or, even more conveniently,
the BeanFactory.Generate annotation).
Usage of BeanFactory.MetaFactory is most easily explained
with an example. First, you define an interface. (Note that it can be an
inner interface.)
public interface MyMetaFactory extends BeanFactory.MetaFactory {
BeanFactory<ListGrid> getListGridFactory();
BeanFactory<TileGrid> getTileGridBeanFactory();
}
... and then you trigger the generation process:
GWT.create(MyMetaFactory.class);
Each function in the interface you define will result in the creation of
one BeanFactory ... so, in this case, we would end up with
bean factories for ListGrid and TileGrid. The rules
are as follows:
BeanFactory.MetaFactoryBeanFactory,
with a generic type that is the class you want the factory for.If you want, you can keep a reference to the results of the GWT.create(),
and call the functions:
MyMetaFactory metaFactory = GWT.create(MyMetaFactory.class); BeanFactory<TileGrid> myTileGridFactory = myMetaFactory.getTileGridBeanFactory();
However, you don't have to do that ... you can ignore the results of GWT.create()
and just use the BeanFactory static API:
GWT.create(MyMetaFactory.class);
Object myGrid = BeanFactory.newInstance("TileGrid");
BeanFactory.setProperty(myGrid, "width", 207);
... except that "TileGrid" would probably be a variable!
You can also use the generated classes in ComponentXML,
by specifying the fully-qualified class name as the constructor for objects.
Note that the call to GWT.create() must occur at run-time before
the factories are used. However, you can modularize by creating some factories
first and other factories later, as long as each factory is created before
being used.
BeanFactory.Generate