如何让 PicoContainer start/stop/dispose 工厂注入的组件？

Question

我有一个缓存所有组件的 PicoContainer。由于它缓存所有组件，我希望它在容器生命周期的适当时间点调用 start、stop 和 dispose。

但是，我发现如果我使用 FactoryInjector 构造组件，则根本不会调用这些方法，尽管该组件也被缓存了。

举个例子：

import java.lang.reflect.Type;

import org.picocontainer.Characteristics;
import org.picocontainer.DefaultPicoContainer;
import org.picocontainer.Disposable;
import org.picocontainer.MutablePicoContainer;
import org.picocontainer.PicoContainer;
import org.picocontainer.Startable;
import org.picocontainer.injectors.FactoryInjector;

public class PicoContainerFactoryTest {
    public static void main(String[] args) {
        MutablePicoContainer container =
            new DefaultPicoContainer().as(Characteristics.CACHE);
        try {
            System.out.println("Adding components...");
            container.addComponent(InstanceService.class,
                                   new InstanceServiceImpl());
            container.addComponent(ConstructedService.class,
                                   ConstructedServiceImpl.class);
            container.addAdapter(
                new FactoryConstructedServiceAdapter());

            System.out.println("Starting...");
            container.start();

            // Even this doesn't trigger it. :(
            //container.getComponent(FactoryConstructedService.class);

            System.out.println("Stopping...");
            container.stop();
        }
        finally
        {
            System.out.println("Disposing...");
            container.dispose();
        }
    }


    public interface InstanceService
        extends Startable, Disposable {}
    public interface ConstructedService
        extends Startable, Disposable {}
    public interface FactoryConstructedService
        extends Startable, Disposable {}

    private static class InstanceServiceImpl extends Impl
            implements InstanceService {
        public InstanceServiceImpl() {
            super("InstanceServiceImpl");
        }
    }

    public static class ConstructedServiceImpl extends Impl
            implements ConstructedService {
        public ConstructedServiceImpl() {
            super("ConstructedServiceImpl");
        }
    }

    private static class FactoryConstructedServiceAdapter
            extends FactoryInjector<FactoryConstructedService> {

        public FactoryConstructedServiceAdapter() {
            super(FactoryConstructedService.class);
        }

        @Override
        public FactoryConstructedService getComponentInstance(
            PicoContainer picoContainer, Type type) {
            return new FactoryConstructedServiceImpl();
        }

        private static class FactoryConstructedServiceImpl extends Impl
            implements FactoryConstructedService {
            public FactoryConstructedServiceImpl() {
                super("FactoryConstructedServiceImpl");
            }
        }
    }

    public static class Impl implements Startable, Disposable {
        private final String name;

        public Impl(String name) {
            this.name = name;
            System.out.println("  " + name + "#<init>");
        }

        @Override
        public void start() {
            System.out.println("  " + name + "#start");
        }

        @Override
        public void stop() {
            System.out.println("  " + name + "#stop");
        }

        @Override
        public void dispose() {
            System.out.println("  " + name + "#dispose");
        }
    }
}

运行的输出如下：

Adding components...
  InstanceServiceImpl#<init>
Starting...
  ConstructedServiceImpl#<init>
  InstanceServiceImpl#start
  ConstructedServiceImpl#start
Stopping...
  ConstructedServiceImpl#stop
  InstanceServiceImpl#stop
Disposing...
  ConstructedServiceImpl#dispose
  InstanceServiceImpl#dispose

因此 start()，我创建并作为实例注入的组件启动了。我通过构造函数注入注入的组件被构建然后启动。但是我通过工厂注入的组件什么也看不到。

就文档而言，FactoryInjector 的 Javadoc 显示了 #start、#stop 和 #dispose 方法，这些方法似乎是为工厂本身准备的做它自己的生命周期的事情，而不是为工厂分拆出来的组件。

快速查看源代码显示实现 ComponentLifecycle 的适配器将调用其方法，但尚不清楚如何将其挂钩。如果我查看其他实现类，几乎所有事情似乎都委托给了其他事情，因此很难弄清楚到底发生了什么。

正确的做法是什么？有没有正确的方法来做到这一点？

Answer 1

FactoryConstructedServiceAdapter 应该实施 LifecycleStrategy 并且有

@Override
public boolean hasLifecycle(Class<?> type) {
    return true;
}

基本上，仅此而已，工厂将包含在标准生命周期中并且可以管理组件并且将调用 FactoryConstructedServiceImpl 的实际实例化（如果您不需要工厂提供的组件的生命周期并且只是想知道为什么它没有被实例化，请记住工厂是惰性的，在您实际连接或请求组件之前，您不会在日志中看到 "FactoryConstructedServiceImpl#init"。

如果你需要一个大的例子，就拿InstanceAdapter。

如何让 PicoContainer start/stop/dispose 工厂注入的组件？

How do I get PicoContainer to start/stop/dispose a component injected by a factory?

java

dependency-injection

factory

picocontainer