几个关于Guice的问题，关心Guice的请进

最近考虑在项目中使用guice，但是在替换一些Design patterns时遇到一些问题，特来这里向大家请教。

Guice的文档实在是太简单了，基本上就是几个简单的对象来回映射，对实际开发基本上没什么用。网上的例子也基本上停留在1+1=2的水平。

下面是我遇到的问题：

1. 如何在运行时态注入同一个对象的不同的实例？
   首先一个POJO：

 public class Foo {

    private boolean a;
    private boolean b;

    @inject
    public Foo(boolean a, boolean b) {
        this.a = a;
        this.b = b;
    }
} 

然后使用它：

public class FooContainer {

    @inject
    private Foo foo;

} 

我的问题是，Foo对象根据属性不同可以生成4中不同的实例，那么如何能够在runtime动态注入不同的实例呢？
另外，使用@Name注释可以绑定不同的实例，但是似乎无法动态绑定，而且如果类属性比较多的话，把每一种可能的实例都绑定起来，岂不是要吐血了。

2. 如何在runtime动态绑定任意对象？

 public class Foo {
           @inject
           private Object o;
     } 

这个例子里，Foo对象需要使用任意类型的对象实例，如何用Guice动态注入？类型为Object的对象实例为无限多，用@Name应该是解决不了问题了。

3. 如何解决传递对象问题？
   在API调用过程中，借助方法参数，可以将某一个对象实例在几个对象之间来回传递，而且它也不是singelton，这个被传递的对象不一定是Value Object。如果使用Guice的话如何实现？

4. 如何解决动态扩展的问题？
   为了便于理解，我举个简单的例子，MVC模式大家应该都很清楚，假如一个Control对应一个Model的话，用Guice可以完美实现。但是如果一个Control可以控制多个Model，而Model的数量是动态的，也就是说Control需要在runtime创建新的Model，同时还要保存已经存在的Models。针对这种情况，如何使用Guice注入？

5. 如何注入String？
   我刚刚开始接触Guice，估计用过Guice的朋友能够马上回答这个问题。先举个例子：

 public class Foo {

    @inject
    private String a;

    public Foo(String a) {
        this.a = a;
    }
} 

在使用Foo对象时，如何动态注入不同的String值？
其实这个问题和前面的几个问题类似，但是String是一个比较特殊的对象，所以单独拿出来提问。

6. 如何解决类关联的问题。例如：

public class Foo {

    private Bar bar;

    public Foo() {
        bar = new Bar(this);
    }

public class Bar {

    private Foo foo;

    public Bar(Foo foo) {
      this.foo = foo;
    }

如何保证使用guice注入后，bar中的foo是创建Bar的那个Foo对象实例？

评论

26 楼 hy2012_campus 2016-07-08  

想想你请教下你们是在什么情况下不适用spring合适选择guice，最近在看guice

25 楼 b051 2008-04-24  

sigh... 真不知道在说什么, 也不知道我理解到多少. 但总归来说, 感觉还是个设计问题. 不妨退一步看看是不是自己的设计正确, 或者如果没有A框架B框架你该怎么做.

这什么动态注入, 真的需要注入么? 用注入的描述和注入工厂产生你要被注的对象可以么? 或者一共有多少种, 少的话就变成静态的呗.

24 楼 polygoncell 2008-04-22  

ajoo 写道

主要还是没有看懂到底问题是什么。怎么需要这些holder类的呢？还是觉得让例子说话比较好。比如如果你手工注入的话是什么样子的？

例子涉及到很多第三方的类库，讲解起来反而麻烦。

这段时间正在努力把Guice整合到项目中去，忙得要死，等到整合完毕来，再来这里发表一下感想。

23 楼 ajoo 2008-04-17  

主要还是没有看懂到底问题是什么。怎么需要这些holder类的呢？还是觉得让例子说话比较好。比如如果你手工注入的话是什么样子的？

22 楼 polygoncell 2008-04-17  

javazhujf 写道

搂主提的问题大都是围绕实例来说的，但是我觉得Guice是针对接口和接口的不同实现类之间的绑定，使我们可以只关注面向接口的编程。比如实现类是连接RDB还是LDAP还是其它的数据源我们并不关心，这使我们的程序容易扩展。

你说的这个只是Guice提供的一部分功能。没有接口的类很多，例如POJO。

21 楼 polygoncell 2008-04-17  

birdjavaeye 写道

polygoncell 写道

非常感谢，写了这么一大堆。：-）

这种做法和我考虑的一样，问题是这样也太麻烦了吧！
只是 new FooContainer(new Foo(true, false))和new FooContainer(new Foo(false, true))就能搞定的，结果用Guice写了这么多代码。

还有就是关于String的那个问题还存在。我再举例说明一下。在程序的某处需要Foo对象，例如Foo("ABC"), 过段时间，在其他地方又需要Foo("DEF"), 再过段时间，又需要Foo（"XZY"）就这样继续下去。。。。。。

我怎么用一个Foo类类实现这些映射？这些String之间并没有任何规律可循。

可以试试objot2的ioc容器

Container stub = new Factory() {
  @Override
  protected Object doBind(Class<?> c, Bind b) throws Exception {
    if (c == Foo.class)
      return b.mode(Inject.Set.class); // 通过set来指定对象
    return b;
  }
}.bind(Foo.class).create(null);

Container c1 = stub.create();
c1.set(Foo.class, new Foo(true, false));

Container c2 = stub.create();
c2.set(Foo.class, new Foo(false, true));

这样c1、c2就可以绑定Foo到不同的对象上

不同时候要不同Foo时，如果流程上的先后能确定，那可以：

Container c = stub.create();
...
c.set(Foo.class, foo1);
c.get(FooClient1.class);
...
c.set(Foo.class, foo2);
c.get(FooClient2.class);
...

不过那些在set前就由容器创建的对象（例如已经获取的singleton）看不到set的东西

这个..... 我目前只考虑Guice。不过还是谢谢了。

20 楼 javazhujf 2008-04-17  

搂主提的问题大都是围绕实例来说的，但是我觉得Guice是针对接口和接口的不同实现类之间的绑定，使我们可以只关注面向接口的编程。比如实现类是连接RDB还是LDAP还是其它的数据源我们并不关心，这使我们的程序容易扩展。

19 楼 birdjavaeye 2008-04-16  

polygoncell 写道

非常感谢，写了这么一大堆。：-）

这种做法和我考虑的一样，问题是这样也太麻烦了吧！
只是 new FooContainer(new Foo(true, false))和new FooContainer(new Foo(false, true))就能搞定的，结果用Guice写了这么多代码。

还有就是关于String的那个问题还存在。我再举例说明一下。在程序的某处需要Foo对象，例如Foo("ABC"), 过段时间，在其他地方又需要Foo("DEF"), 再过段时间，又需要Foo（"XZY"）就这样继续下去。。。。。。

我怎么用一个Foo类类实现这些映射？这些String之间并没有任何规律可循。

可以试试objot2的ioc容器

Container stub = new Factory() {
  @Override
  protected Object doBind(Class<?> c, Bind b) throws Exception {
    if (c == Foo.class)
      return b.mode(Inject.Set.class); // 通过set来指定对象
    return b;
  }
}.bind(Foo.class).create(null);

Container c1 = stub.create();
c1.set(Foo.class, new Foo(true, false));

Container c2 = stub.create();
c2.set(Foo.class, new Foo(false, true));

这样c1、c2就可以绑定Foo到不同的对象上

不同时候要不同Foo时，如果流程上的先后能确定，那可以：

Container c = stub.create();
...
c.set(Foo.class, foo1);
c.get(FooClient1.class);
...
c.set(Foo.class, foo2);
c.get(FooClient2.class);
...

不过那些在set前就由容器创建的对象（例如已经获取的singleton）看不到set的东西

18 楼 polygoncell 2008-04-16  

ajoo 写道

不是的。你那个类是本来就存在的。

....
assist inject帮你节省了最后一步，它用动态代理自动帮你生成FooFactoryImpl。

噢，对对，你理解的对。

但是factory里面的create方法不总是这么简单的，有很多会是这样：

class FooFactoryImpl implements FooFactory {
  private final Bar bar;

  public Foo createFoo(String id，String s, Object... o) {
    Foo foo = new Foo(id);
    // call some other API and do something with foo and other parameters, 
    // for example decorate the Foo.
    return foo; 
  }
}

针对这样情况，如果使用Guice+AI，就得再继续编码，如果Foo是我们项目内部的类，那么可以将后续代码直接写进一个新的Foo constructor里去，例如：

class Foo {
   ....

  @inject
  public Foo(String id，String s, Object... o) {
    this.id = id;
    // call some other API and do something with foo and other parameters, 
    // for example decorate the Foo. 
  }
}

但是这样做有两个缺点，1. 第三方API直接和Foo POJO产生紧耦合。 2. Guice只允许一个constructor拥有@inject，也就是说使用了这个constructor，原来那个单纯使用String的constructor就没法用了。

考虑到这些情况，就得再写一个类，也就是我前面说的针对每一个create方法得再写一个类（以及接口），这个类可以直接继承Foo：

class Foo1 extends Foo {
   ....

  @inject
  public Foo1(String id，String s, Object... o) {
    super(id);
    // call some other API and do something with foo and other parameters, 
    // for example decorate the Foo. 
  }
}

这样factory接口不需要发生变化。

这个类也可以是一个Foo类的Holder（个人认为这样更好）：

class FooHolder {
   private Foo foo;
   // define some property from the other API
  
  @inject
  public Foo1(String id，String s, Object... o) {
    foo = new Foo(id);
    // call some other API and do something with foo and other parameters, 
    // for example decorate the Foo. 
  }

  // Getters
}

这样做避免了不必要的继承，FooHolder不但可以提供Foo，而且可以提供需要的其他对象。但是缺点是我们需要修改Factory中ocreate方法的返回值：

public interface FooFactory {
  FooHolder createFoo(String id);
}

并且将FooHolder而非Foo注入到其他类中去。

但是这样一来，原来只是一个大的Factory类，现在就变成了一个Factory接口，加上一堆小的Holder类及其接口，类的数量增加了很多。整体感觉还是保留Factory类，然后将Factory注入到需要它的地方显得更便捷。

17 楼 quaff 2008-04-16  

yujiang 写道

quaff 写道

动态注入在spring里面是这样解决的,一次注入但是根据session的不同注入的是不同的Cart实例.
<bean id="cart" class="test.Cart" scope="session">
<aop:scoped-proxy />
</bean>

guice一样可以用scope加proxy解决,要自己去定制.

这个是用来解决 Scope不一注入的,同这个帖子讨论的不一样

请看楼主说的第四条

16 楼 yujiang 2008-04-16  

quaff 写道

动态注入在spring里面是这样解决的,一次注入但是根据session的不同注入的是不同的Cart实例.
<bean id="cart" class="test.Cart" scope="session">
<aop:scoped-proxy />
</bean>

guice一样可以用scope加proxy解决,要自己去定制.

这个是用来解决 Scope不一注入的,同这个帖子讨论的不一样

15 楼 quaff 2008-04-16  

动态注入在spring里面是这样解决的,一次注入但是根据session的不同注入的是不同的Cart实例.
<bean id="cart" class="test.Cart" scope="session">
<aop:scoped-proxy />
</bean>

guice一样可以用scope加proxy解决,要自己去定制.

14 楼 ajoo 2008-04-16  

不是的。你那个类是本来就存在的。
assist inject要解决的问题是，一个类已经存在了（就象你的那个要动态注入Object的类），有些参数是由guice注入的，而有些是动态注入的。比如：

public class Foo {
  public Foo(String id, Bar bar); // id是动态注入
}

这时候，如果没有guice或者任何di容器，你也要写一个factory接口：

public class FooFactory {
  Foo createFoo(String id);
}

然后在客户代码处：

private final FooFactory factory;

Foo foo1 = factory.createFoo("a");
Foo foo2 = factory.createFoo("b");

如此，你还是一切都是依赖注入，而不必关心你不关心的Bar。

最后要手工实现FooFactory:

class FooFactoryImpl implements FooFactory {
  private final Bar bar;

  public Foo createFoo(String id) {
    return new Foo(id, bar);
  }
}

assist inject帮你节省了最后一步，它用动态代理自动帮你生成FooFactoryImpl。

13 楼 polygoncell 2008-04-16  

ajoo 写道

polygoncell 写道

ajoo 写道

你这个情况还相对比较简单，可以看看assisted inject。对这中浅浅的就一层的动态注入还是可以应付的。

我一直比较纳闷的是，用pico/spring怎么解决这个问题呢？

我只是把我的问题简化了，实际问题里有好多参数，包括Object。

assisted inject我也刚刚看到，刚才在guice用户组里面也问了半天，不知道这个会不会整合到Guice 2.0里面去。

但是Assisted inject用起来并不简单，首先需要一个Factory interface，然后针对每一个create方法，要编写一个类（最好这个类实现一个接口）。这样搞起来，原来一个Factory类搞定的事情，用Guice加上AI可能要编写几十个类和接口才能搞得定。整体感觉还不如直接inject一个Factory类。

factory interface 总归要要的。那么多参数，你一个一个手工new也一样麻烦啊。

但是“针对每一个create方法，要编写一个类”是什么意思？

这个是我在它的文档里读到的， http://publicobject.com/publicobject/assistedinject/javadocs/index.html
先是一个Factory：

public interface PaymentFactory {
    Payment create(Date startDate, Money amount);
 }

然后针对这个create方法写一个类：

public class RealPayment implements Payment {
    @AssistedInject
    public RealFoo(CreditService creditService, AuthService authService,
      @Assisted Date startDate, @Assisted Money amount) {
     ...
  }
 }

这里是binding：

  bind(FooFactory.class)
     .toProvider(FactoryProvider.newFactory(PaymentFactory.class, RealPayment.class));

12 楼 ajoo 2008-04-15  

polygoncell 写道

ajoo 写道

你这个情况还相对比较简单，可以看看assisted inject。对这中浅浅的就一层的动态注入还是可以应付的。

我一直比较纳闷的是，用pico/spring怎么解决这个问题呢？

我只是把我的问题简化了，实际问题里有好多参数，包括Object。

assisted inject我也刚刚看到，刚才在guice用户组里面也问了半天，不知道这个会不会整合到Guice 2.0里面去。

但是Assisted inject用起来并不简单，首先需要一个Factory interface，然后针对每一个create方法，要编写一个类（最好这个类实现一个接口）。这样搞起来，原来一个Factory类搞定的事情，用Guice加上AI可能要编写几十个类和接口才能搞得定。整体感觉还不如直接inject一个Factory类。

factory interface 总归要要的。那么多参数，你一个一个手工new也一样麻烦啊。

但是“针对每一个create方法，要编写一个类”是什么意思？

11 楼 polygoncell 2008-04-15  

ajoo 写道

你这个情况还相对比较简单，可以看看assisted inject。对这中浅浅的就一层的动态注入还是可以应付的。

我一直比较纳闷的是，用pico/spring怎么解决这个问题呢？

我只是把我的问题简化了，实际问题里有好多参数，包括Object。

assisted inject我也刚刚看到，刚才在guice用户组里面也问了半天，不知道这个会不会整合到Guice 2.0里面去。

但是Assisted inject用起来并不简单，首先需要一个Factory interface，然后针对每一个create方法，要编写一个类（最好这个类实现一个接口）。这样搞起来，原来一个Factory类搞定的事情，用Guice加上AI可能要编写几十个类和接口才能搞得定。整体感觉还不如直接inject一个Factory类。

10 楼 ajoo 2008-04-15  

你这个情况还相对比较简单，可以看看assisted inject。对这中浅浅的就一层的动态注入还是可以应付的。

我一直比较纳闷的是，用pico/spring怎么解决这个问题呢？

9 楼 williamy 2008-04-15  

ajoo 写道

polygoncell 写道

非常感谢，写了这么一大堆。：-）

这种做法和我考虑的一样，问题是这样也太麻烦了吧！
只是 new FooContainer(new Foo(true, false))和new FooContainer(new Foo(false, true))就能搞定的，结果用Guice写了这么多代码。

还有就是关于String的那个问题还存在。我再举例说明一下。在程序的某处需要Foo对象，例如Foo("ABC"), 过段时间，在其他地方又需要Foo("DEF"), 再过段时间，又需要Foo（"XZY"）就这样继续下去。。。。。。

我怎么用一个Foo类类实现这些映射？这些String之间并没有任何规律可循。

考虑用FooFactory？其实你最好写一个不用Guice的话，你手工会怎么写，这样可以帮助大家理解。

你這種問題，注入是不能解決問題的，因未注入不是解決這個問題的，因未在注入的時候，還沒有你說的Foo（“abc”）這些實例的存在，
解決這個問題，你可以運用state模式，不過更好的方法，還是if+else，（或者不要else）

8 楼 polygoncell 2008-04-15  

ajoo 写道

polygoncell 写道

非常感谢，写了这么一大堆。：-）

这种做法和我考虑的一样，问题是这样也太麻烦了吧！
只是 new FooContainer(new Foo(true, false))和new FooContainer(new Foo(false, true))就能搞定的，结果用Guice写了这么多代码。

还有就是关于String的那个问题还存在。我再举例说明一下。在程序的某处需要Foo对象，例如Foo("ABC"), 过段时间，在其他地方又需要Foo("DEF"), 再过段时间，又需要Foo（"XZY"）就这样继续下去。。。。。。

我怎么用一个Foo类类实现这些映射？这些String之间并没有任何规律可循。

考虑用FooFactory？其实你最好写一个不用Guice的话，你手工会怎么写，这样可以帮助大家理解。

我是想尽量简化问题，这样大家讨论起来比较方便。

手动写就是 new Foo("any String"), 什么地方需要了，就创建一个。问题是参数可以是任何String，无法预先定义。

用FooFactory？ 你的意思是@inject FooFactory，然后让FooFactory创建Foo对象？不是所有对象创建的工作都应该交给Guice来完成么？这样做是不是有些背离了Guice了？

7 楼 ajoo 2008-04-15  

polygoncell 写道

非常感谢，写了这么一大堆。：-）

这种做法和我考虑的一样，问题是这样也太麻烦了吧！
只是 new FooContainer(new Foo(true, false))和new FooContainer(new Foo(false, true))就能搞定的，结果用Guice写了这么多代码。

还有就是关于String的那个问题还存在。我再举例说明一下。在程序的某处需要Foo对象，例如Foo("ABC"), 过段时间，在其他地方又需要Foo("DEF"), 再过段时间，又需要Foo（"XZY"）就这样继续下去。。。。。。

我怎么用一个Foo类类实现这些映射？这些String之间并没有任何规律可循。

考虑用FooFactory？其实你最好写一个不用Guice的话，你手工会怎么写，这样可以帮助大家理解。