15

I would like to ask what's the difference between

bindConstant().annotatedWith(Names.named("keepAliveInterval")).to(60);

and

bind(Integer.TYPE).annotatedWith(Names.named("keepAliveInterval")).toInstance(60);

I would like to load all my configuration properties with Names.bindProperties(binder(), prop); in my module and I discovered that it uses the latter one for binding properties.

Thanks, regards

Marek

zeratul021
  • 2,644
  • 3
  • 32
  • 45

2 Answers2

10

I think reasons to use bindConstant() are:

  • It requires that you use an annotated binding. You can't do bindConstant().to(foo). Since the types you bind with it are primitives and Strings, it's unlikely that an annotation-less binding would make sense for any of them.
  • It requires less effort since you don't have to specify the type (by the way, bindConstant() binds an int to Integer.class rather than Integer.TYPE, not sure if that matters).

I think Names.bindProperties doesn't use bindConstant just because it's internal code and a little more code is OK to skip a step or two in the process of making a binding. In your own modules, I'd just use bindConstant because it's easy and more clear.

ColinD
  • 108,630
  • 30
  • 201
  • 202
4

bindConstant() has the benefit of being able to set different primitives because of predefined TypeConverter instances within Guice itself.

Take the following binding definition as an example:

bindContant().annotatedWith(@Names.named("c")).to("30");

Then in a class where you want the injection:

@Inject @Named("c") int value;

Guice will convert the bound String into an int for you. If it cannot, it will say so.

The benefit of bindConstant() is the type conversion that can happen. Explicitly binding an int does not give you that luxury.

gpampara
  • 11,989
  • 3
  • 27
  • 26
  • 1
    As evidenced by how `bindProperties()` doesn't use `bindConstant()`, this isn't completely true. Using `bind(String.class) ... .toInstance("30")` works fine and allows the binding to be converted to an `int` just like `bindConstant()`. I don't believe the `TypeConverter` stuff cares how you made the binding to begin with. – ColinD Nov 13 '10 at 15:11
  • Well actually, as I mentioned in my OP, Names.bindProperties doesn't use bindConstant and nevertheless the type conversion occurs (e.g. host and port are String and int and they are both properly injected as the types they are - no conversion errors) – zeratul021 Nov 13 '10 at 17:01
  • 1
    True, it doesn't. From a user's point of view though, that should be be taken into account because it is internal logic of Guice. – gpampara Nov 15 '10 at 08:06