GWT.create vs new operator alternative - gwt

Question

I have to use parametric constructor of my class in GWT.create, but GWT only calls default constructor. I was thinking to replace call of GWT.create with call to new Class(arguments list). Is it the right way to code in GWT deferred binding.
Code is below:
public interface ProductSelectorMetaFactory extends BeanFactory.MetaFactory {
BeanFactory<ProductSelectorTile> getProductSelectorTileFactory();
}
public CustomTileGrid(DataSource cardViewDataSource, ProductSelectorTile tileType, String fieldState,
List<DetailViewerField> list) {
setDataSource(cardViewDataSource);
setAutoFetchData(true);
GWT.create(ProductSelectorMetaFactory.class);
setTileConstructor(tileType.getClass().getName());
}
Here I want to use parameter constructor of ProductSelectorTile class. How can I use this.
Any help is appreciated.
I might be not good in explaining my current problem but feel free if you have any doubt to understand this question.

Answer 1

I would use a helper class with no parameters that can be created by GWT.create(). That helper class can have different implementations - the same as your original class (with parameters). Now, each implementation of helper class can create a proper instance of the original class.
Let's assume that you need different implementations for each user agent. In <module>.gwt.xml you would have this (see documentation):
<replace-with class="<module.path>.MyClassHelperGecko">
<when-type-is class="<module.path>.MyClassHelper" />
<when-property-is name="user.agent" value="gecko1_8" />
</replace-with>
<replace-with class="<module.path>.MyClassHelperSafari">
<when-type-is class="<module.path>.MyClassHelper" />
<when-property-is name="user.agent" value="safari" />
</replace-with>
...
The helper class and its implementations:
public class MyClassHelper {
MyClassInterface getInstance(String param) {
return null;
};
}
public class MyClassHelperGecko extends MyClassHelper {
#Override
public MyClassInterface getInstance(String param) {
return new MyClassGecko(param);
}
}
public class MyClassHelperSafari extends MyClassHelper {
#Override
public MyClassInterface getInstance(String param) {
return new MyClassSafari(param);
}
}
...
And finally implementations of the base class:
public interface MyClassInterface {
// ...
}
public class MyClassGecko implements MyClassInterface {
public MyClassGecko(String param) {
Window.alert("Gecko implementation; param = " + param);
// ...
}
}
public class MyClassSafari implements MyClassInterface {
public MyClassSafari(String param) {
Window.alert("Safari implementation; param = " + param);
// ...
}
}
...
Use it like this and you will see different alerts for different user-agents:
MyClassHelper helper = GWT.create(MyClassHelper.class);
helper.getInstance("abc");
This is a general Deferred Binding Using Replacement solution. There is also Deferred Binding using Generators method. Once you get the idea you can choose the method that is best for you.