Helper class as a singleton with Guice

Question

I'm learning Google Guice. I understood how to bind an interface to its implementation.

Now, I have the following helper class :

class PersonHelper {
   public static FakeDatabaseConfiguration dbConfig;
   public PersonHelper(){
      if (dbConfig == null){
          dbConfig = new FakeDatabaseConfiguration();
          dbConfig.setHost('127.0.0.1');
          dbConfig.setPort('3306');
          dbConfig.setUsername('root');
          dbConfig.setPassword('root');
       }
   }

   public List<Person> getPersons(){
      FakeResult fakeResult = dbConfig.executeSQL("select * from Person");
      return fakeResult.asList();
   }
}

Today, I'm using it like this:

PersonHelper personHelper = new PersonHelper();
List<Person> personsList = personHelper. getPersons();

I'm pretty sure there is a way to make this class better.

Question : How can I make this class as a singleton using Guice so that I don't lazy load the dbConfig variable at each instanciation ? (I read that there is a @Singleton annotation but, it's considered in Guice just as a scope.)

Regards

score 0 · Answer 1 · edited May 23 '17 at 12:07

0

Please look at Binding @Provides method as eager singleton See if that helps. The eagerSingleton part might work for you.

edited May 23 '17 at 12:07

Community

1
1

answered May 25 '16 at 19:40

Prashant

1,002
13
29

I did read that answer but I cannot adapt it to my situation. Can you please explain your understanding with code (mine if possible) ? – Bendren May 25 '16 at 20:16

score 0 · Answer 2 · answered May 25 '16 at 21:43

Having it as a scope is exactly what you want: Scopes effectively tell Guice when it's allowed to reuse the same object it's already created, and for @Singleton that answer is "always".

If you were to list the class like this:

@Singleton  // Could also be in your module or @Provides method.
class PersonHelper {
  private FakeDatabaseConfiguration dbConfig;

  public PersonHelper(){
    dbConfig = new FakeDatabaseConfiguration();
    dbConfig.setHost('127.0.0.1');
    dbConfig.setPort('3306');
    dbConfig.setUsername('root');
    dbConfig.setPassword('root');
  }

  public List<Person> getPersons(){
    FakeResult fakeResult = dbConfig.executeSQL("select * from Person");
    return fakeResult.asList();
  }
}

Then the the class itself becomes a Singleton. The FakeDatabaseConfiguration will be created whenever the class is instantiated, but for all accesses through Guice, that will only happen once.

Of course, none of this applies to direct constructor calls as new PersonHelper(), but with few exceptions Guice is only good at making guarantees about objects that it provides. Any accesses that Guice can control, including through getInstance or @Inject-annotated fields and constructors, will only see PersonHelper (and therefore FakeDatabaseConfiguration) created exactly once.

Imho it is a good "rule of thumb" when using DI to avoid using "new" whenever possible. In this case: Why creating a singleton "Helper" that creates a DB-config? Provide that DbConfig directly in your module and then just implement a "Provider>" that gets the config injected and returns the list in its "get" method. That way the Setup is completely managed by the module and you do not need helpers anymore. — Jan Galinski, May 26 '16 at 06:23
@Jan Agree about eradicating `new` but disagree strongly that helpers can all be eliminated by making their return values directly injectable. For helpers that are _de facto_ providers, sure, but I don't see that being the case here—especially with a database call and list of model objects involved. There is still plenty of room for injecting singleton helpers, particularly if they are made mockable for testing. — Jeff Bowman, May 26 '16 at 06:29

Zakaria · Accepted Answer · 2016-05-26T13:26:32.057

First, in your module, you have to declare a provider (FakeDatabaseConfigurationProvider). As stated, this is the best way to inject a configuration object. Then, declare your helper class as a Singleton and bind it in your module. This will allow your helper class to be used like this :

public class SomeClass{
  @Inject
  private PersonHelper personHelper;
  ...
  public void someMethod(){
    ...
    List<Person> personsList = personHelper.getPersons();
    ..
  }
}

And the same instance will be shared through your app.

Here is the suggested code :

public class MyModule extends AbstractModule {

  @Override
  protected void configure() {
    bind(FakeDatabaseConfiguration.class).toProvider(FakeDatabaseConfigurationProvider.class);
    bind(PersonHelper.class).in(Scopes.SINGLETON);
  }

  /**
   * FakeDatabaseConfigurationProvider implementation
   */
  static class FakeDatabaseConfigurationProvider implements Provider<FakeDatabaseConfiguration> {

    @Override
    public FakeDatabaseConfiguration get() {
      FakeDatabaseConfiguration dbConfig = new FakeDatabaseConfiguration();
      dbConfig.setHost('127.0.0.1');
      dbConfig.setPort('3306');
      dbConfig.setUsername('root');
      dbConfig.setPassword('root');
      return dbConfig;
    }
  }
}

Then, in your PersonHelper :

public class PersonHelper{
    private FakeDatabaseConfiguration fakeDatabaseConfiguration;
    @Inject
    public PersonHelper(final FakeDatabaseConfiguration fakeDatabaseConfiguration){
        this.fakeDatabaseConfiguration = fakeDatabaseConfiguration;
    }

    public List<Person> getPersons(){
      FakeResult fakeResult = fakeDatabaseConfiguration.executeSQL("select * from Person");
      return fakeDatabaseConfiguration.asList();
    }

}

Helper class as a singleton with Guice

3 Answers3