GWT Gin Async Service Injection

Question

I have a question about using Gin to inject GWT Async RPC service.

I have two classes both using the same Async service:

class TheViewA {    
    @Inject
    public TheViewA(MyServiceAsync myServiceASync) {
        ....
    }
}


class TheViewB {
    @Inject
    public TheViewB(MyServiceASync myServiceASync) {
        ....
    }
}

This works fine. However, I found out this will cause GWT internally call:

GWT.create(MyServiceASync.class)

twice for each injection. I don't know what is the disadvantage of this, but I am thinking they can both share a single MyServiceAsync instance.

Can someone tell me how to configure Gin (Guice) so that only one instance of MyServiceAsync is created for both injection?

Or Is it OK to create separate instances for both injection and why?

Many thanks.

It would be better to have singleton instance of asyn class performance wise. I am not sure on the gin part though. — appbootup, Mar 16 '13 at 16:05
@SSR can you elaborate? The compiled code remote service async code is pretty bare bones, I'm not sure what would be better about creating fewer instances... — Colin Alworth, Mar 16 '13 at 17:15
We had profiled and interpreted that creation of remote service async was taking time ( around couple of years ago ) and moved to singleton approach. — appbootup, Mar 17 '13 at 08:33

score 1 · Accepted Answer · answered Mar 16 '13 at 17:05

When it comes to injection, if Gin does not find a bind for a given type, it automatically fallsback to GWT.create() to create an instance. This is why ClientBundle/GWT-RPC/i18n and the like, simply Just Works, and you do not have to bind them into your own extension of AbstractGinModule.

Of course when Gin finds another injection of the same type, it injects another instance. To create and inject a singleton instance simply bind your GWT-RPC async service interface into @Singleton scope. Like this:

public class YourModule extends AbstractGinModule {
  @Override
  protected void configure() {
    bind(MyServiceAsync.class).in(Singleton.class);
  }
}

Or you can create a Provider<MyServiceAsync> that always returns a singleton instance, but the previous approach is far simpler.

A singleton async instance injected throughout your application, is generally preferred.

And to answer the other question, yes, it is okay to create multiple RPC instances - they don't hold any state, so making more won't use an appreciable amount of memory. Adding the `Singleton` scope is the correct way to avoid making other instances, but in this case, I really wouldn't worry about it - I've never heard of or seen a reason to prefer a singleton of this. In contrast, `RequestFactory` requires setup that you could avoid, but I'm not sure it is worth it there either. — Colin Alworth, Mar 16 '13 at 17:13

GWT Gin Async Service Injection

1 Answers1