Suggestion for solving the "robot legs" problem

[Esko Luontola]

Would it be possible to solve the "robot legs" problem like this?

bind(Leg.class).annotatedWith(Left.class).to
(Leg.class).injecting(LeftFoot.class);
bind(Leg.class).annotatedWith(Right.class).to
(Leg.class).injecting(RightFoot.class);

The Leg class has a constructor parameter of type Foot and possibly
also other parameters. The "injecting" method is used to define the
Foot implementation that will be injected to Leg.

Here are some issues that will still need to be thought about:

- It should be possible to specify multiple explicit dependencies, for
example "injecting(LeftFoot.class, LeftKnee.class)" or "injecting
(LeftFoot.class).injecting(LeftKnee.class)". In the latter case it
would be possible to also specify the dependencies as object instances
or providers, by having overloaded "injecting" methods or
"injectingInstance", "injectingProvider" etc. methods.

- How to handle the cases where Foot is not a direct dependency of
Leg, but instead the dependency of one of Leg's dependencies?

- What would be the best name for the "injecting" method? One other
possibility is "usingDependencies".

[Robbie Vanbrabant]

Guice 2.0's private modules addresses the robot legs problem:
http://google-guice.googlecode.com/svn/trunk/latest-javadoc/com/google/inject/PrivateModule.html

Also see the FAQ item on this:
http://code.google.com/p/google-guice/wiki/FrequentlyAskedQuestions

Cheers
Robbie

[Esko Luontola]

I know about private modules. I just thought that it would be nicer to
do it with less code.

[tzwoenn]

There is actual no binding for Foot.class to LeftFoot.class, so I ask
myself how should guice figure out, which Foot to inject? Just because
LeftFoot extends/implements Foot? Analysing type inheritance is too
much magic. If there a dependency fo Object, you would also get a
LeftFoot injected.

Even though private modules is not that intuitive than your
suggestion, it is type safe and comprehensible.

Regards, Sven

[Jeff Axelrod]

Take a look at Gimlet.  It uses Guice and provides better abstractions for the robot legs problem.  I've used it quite a bit.

Client code looks like this:

public class RobotLegModule extends AbstractModule {
  @Override protected void configure() {
    bind(Sneaker.class).to(NewBalanceSneaker.class);

    install(new LegModuleBuilder()
        .bind(RobotLeg.class)
        .using(Sneaker.class)
        .build()));
  }