想象一下，我有一个类Disposable，有些类实现：
class FactoryImpl implements Disposable {}
我可以将这个类绑定为单例：
bind(Factory.class)
.to(FactoryImpl.class)
.in(Singleton.class);
或作为热切的单身人士：
bind(Factory.class)
.to(FactoryImpl.class)
.asEagerSingleton();
请注意，实现具有类型，而不是接口。
如何找到Guice实际创建的所有单身人士以及实施Disposable类型的所有单身人士？
请注意，我不想盲目地调用提供程序中的get()以避免创建我不需要的东西（特别是因为我正在销毁单例，因此创建新的单例可能会导致问题）。
这与How can I get all singleton instances from a Guice Injector?之类的问题相反，只有在界面包含您需要的密钥时才有效。
[编辑] 这是我有多远。这段代码是否正确？
首先，我需要我的界面。
public interface Disposable {
public void dispose();
}
魔术发生在这里：
import java.util.Collections;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.beust.jcommander.internal.Lists;
import com.google.inject.AbstractModule;
import com.google.inject.Injector;
import com.google.inject.Module;
import com.google.inject.Singleton;
import com.google.inject.TypeLiteral;
import com.google.inject.spi.InjectionListener;
import com.google.inject.spi.TypeEncounter;
import com.google.inject.spi.TypeListener;
import com.google.inject.util.Modules;
/** Support for disposable beans. */
@Singleton
public class DisposableListener implements InjectionListener<Object> {
private static final Logger log = LoggerFactory.getLogger(DisposableListener.class);
/** Use this method to create the injector */
public static Module createModule(Module ...modules) {
/* Create a new module with ourself at the start. That way, our listeners will see all bindings. */
List<Module> list = Lists.newArrayList(new DisposingModule());
Collections.addAll(list, modules);
return Modules.combine(list);
}
/** To dispose all disposables, call this method.
*
* <p>Good places to call this is at the end of {@code main()},
* in an destroy listener of a {@link javax.servlet.ServletContext}, or after a test.
*/
public static void dispose(Injector injector) {
injector.getInstance(DisposableListener.class).disposeAll();
}
/** Everything that is disposable */
private List<Disposable> beans = Lists.newArrayList();
private void disposeAll() {
log.debug("Disposing {} beans", beans.size());
for(Disposable bean: beans) {
try {
bean.dispose();
} catch(Exception e) {
log.warn("Error disposing {}", bean, e);
}
}
}
@Override
public void afterInjection(Object injectee) {
if(injectee instanceof Disposable) {
log.debug("Noticed disposable bean {}", injectee);
beans.add((Disposable) injectee);
}
}
/** Module which creates the {@link DisposableListener} for the injector and sets everything up. */
private static class DisposingModule extends AbstractModule {
@Override
protected void configure() {
DisposableListener disposableListener = new DisposableListener();
/* Attach a type listener to Guice which will add disposableListener to all types which extend Disposable */
bindListener(TypeMatchers.subclassesOf(Disposable.class), new TypeListener() {
@Override
public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
Class<?> clazz = type.getRawType();
log.debug("Found disposable: {}", clazz);
encounter.register(disposableListener);
}
});
/* Add the listener instance to the module, so we can get it later */
bind(DisposableListener.class)
.toInstance(disposableListener);
}
}
}
代码包装其他模块，并确保早期在注入器中安装DisposableListener。然后它会侦听创建的新实例并将其收集到列表中。
代码可能应该检查这些都是单身，但我不知道该怎么做。
以下是单元测试：
import static org.junit.Assert.*;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import com.beust.jcommander.internal.Lists;
import com.google.common.base.Joiner;
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Singleton;
public class DisposableListenerTest {
private static List<String> events = Lists.newArrayList();
@Before
public void clearEvents() {
events.clear();
}
@Test
public void testEagerNoGetInstance() {
Injector injector = Guice.createInjector(DisposableListener.createModule(new TestEagerSingleton()));
// No call to getInstance()
DisposableListener.dispose(injector);
assertEvents("Foo created", "Foo disposed");
}
@Test
public void testEagerGetInstance() {
Injector injector = Guice.createInjector(DisposableListener.createModule(new TestEagerSingleton()));
Foo inst1 = injector.getInstance(Foo.class);
Foo inst2 = injector.getInstance(Foo.class);
DisposableListener.dispose(injector);
assertSame(inst1, inst2); // validate singleton
assertEvents("Foo created", "Foo disposed");
}
@Test
public void testLazyNoGetInstance() {
Injector injector = Guice.createInjector(DisposableListener.createModule(new TestLazySingleton()));
// No call to getInstance()
DisposableListener.dispose(injector);
assertEvents();
}
@Test
public void testLazyGetInstance() {
Injector injector = Guice.createInjector(DisposableListener.createModule(new TestLazySingleton()));
Foo inst1 = injector.getInstance(Foo.class);
Foo inst2 = injector.getInstance(Foo.class);
DisposableListener.dispose(injector);
assertSame(inst1, inst2); // validate singleton
assertEvents("Foo created", "Foo disposed");
}
@Test
public void testAnnotation() {
Injector injector = Guice.createInjector(DisposableListener.createModule(new TestLazySingleton()));
FooWithAnnotation inst1 = injector.getInstance(FooWithAnnotation.class);
FooWithAnnotation inst2 = injector.getInstance(FooWithAnnotation.class);
DisposableListener.dispose(injector);
assertSame(inst1, inst2); // validate singleton
assertEvents("FooWithAnnotation created", "FooWithAnnotation disposed");
}
private void assertEvents(String...expectedEvents) {
Joiner joiner = Joiner.on('\n');
String expected = joiner.join(expectedEvents);
String actual = joiner.join(events);
assertEquals(expected, actual);
}
public static class Foo implements Disposable {
public Foo() {
events.add("Foo created");
}
@Override
public void dispose() {
events.add("Foo disposed");
}
}
@Singleton
public static class FooWithAnnotation implements Disposable {
public FooWithAnnotation() {
events.add("FooWithAnnotation created");
}
@Override
public void dispose() {
events.add("FooWithAnnotation disposed");
}
}
public static class TestLazySingleton extends AbstractModule {
@Override
protected void configure() {
bind(Foo.class).in(Singleton.class);
}
}
public static class TestEagerSingleton extends AbstractModule {
@Override
protected void configure() {
bind(Foo.class).asEagerSingleton();
}
}
// TODO test when bean isn't a singleton
}
答案 0 :(得分：1)
首先，手动“处理”单件Guice绑定有点把车放在马前。您应该使用更合适的scope（或定义your own），而不是将对象绑定为单例，然后需要定期清理它们，以便这些对象在其持续时间内具有自然生命周期预计会存在，例如单个请求或测试。
DisposableListener.dispose()上的文档证明了这一点：
调用它的好地方是
main()的末尾，ServletContext的破坏监听器，或者是在测试之后
这些都不是你应该需要的东西：
当.main()终止时，JVM也会很快终止（并且可能是你的injector将超出范围）所以在让二进制终止之前通常不需要做任何这样的清理。
同样，当ServletContext被销毁时，您通常只是要终止JVM，所以只需让它正常退出。
在测试中，您通常应该为每个测试构建隔离注射器，从而避免任何交叉测试污染。当测试结束注射器并且其所有绑定超出范围时，应该没有任何东西可以清理。
当然，您可以创建需要进行清理的对象，例如AutoCloseable实例，但这不应该是Guice的责任。通常，获取可关闭资源的.getInstance()调用站点应负责清理它。或者，模块可以负责创建和管理这些资源。然后在try-with-resources块中构建注入器，该块管理资源模块的生命周期。
如果这些选项不够充分且您真的需要更强大的生命周期语义，请使用适当的生命周期框架，例如Guava's ServiceManager，而不是将Guice合并为一个。
也就是说，在Guice中拥有需要清理的对象本身通常不是一个好主意。请考虑绑定一个包装器类型，该类型允许调用者根据需要打开（和关闭）资源，而不是直接绑定长期存在的有状态资源对象。
如果你确实需要收集绑定在Guice注入器中的几个不相关的对象，请在.configure()时明确地这样做，而不是通过内省隐式地执行。使用Multibinder允许模块通过将它们绑定到聚合它们的Multibinder<Disposable>实例来显式声明需要处理哪些对象。然后你的清理步骤就是：
for (Disposable resource : injector.getInstance(new Key<Set<Disposable>>() {}) {
resource.dispose();
}
这可以避免监听器的“魔力”无声地进入并在您之后清理，而是允许模块作者确定如何最好地处理它们绑定的资源，可选利用这个必要时清理功能。