Al usar Dagger, qué enfoques permitirán la creación de instancias libre / fácil de los campos @Inject en objetos que también se instancian mediante inyección.

Por ejemplo, el siguiente código inyectará un objeto de tipo Bar en un objeto Foo dado. Lo hará en cualquiera de las dos formas que se muestran. Sin embargo, el campo Sly de cada objeto Bar no coincide con ese comportamiento.

Foo

public class Foo {
  @Inject Bar bar;

  public String getValue() {
    return "Foo's bar value: " + bar.getValue();
  }
}

Explosión

public class Bar {
  @Inject Sly sly;

  public String getValue() {
    return "Bar's sly value: " + sly.getValue();
  }
}

Astuto

public class Sly {
  public String getValue() {
    return "Hey!";
  }
}

Módulo

@Module(
    injects = {
        Foo.class,
        Bar.class
    }
)
public class ExampleTestModule {
  @Provides
  Bar provideBar() {
    return new Bar();
  }

  @Provides
  Sly provideSly() {
    return new Sly();
  }
}

Pruebas

public void testWorksWithInject() {
  Foo foo = new Foo();
  ObjectGraph.create(new ExampleTestModule()).inject(foo);
  assertEquals("...", foo.getValue()); // NullPointerException
}

public void testWorksWithGet() {
  Foo foo = ObjectGraph.create(new ExampleTestModule()).get(Foo.class);
  assertEquals("...", foo.getValue()); // NullPointerException
}

En cualquier caso, Bar's Sly no se está instanciando / @ Inyectado. Por supuesto, Dagger permite la inyección del constructor, lo que resuelve el problema. Me gustaría saber si existen alternativas para incluir esas clases en la lista de parámetros de constructores. ¿Qué te funciona bien?