通过构造函数进行依赖注入中的循环依赖

Question

我在一个项目中使用 Netty (4.0.4.Final)，但我一直遇到需要排除的循环依赖。这个问题主要涉及分解循环依赖的概念，但我会为熟悉的人使用一些 Netty 术语。不过，由于我的问题实际上与 Netty 无关，所以我决定不标记它。

下面，我发布了我的代码，省略了我认为不相关的部分。

情况

我有一个MyServer 类，它将ChannelInboundHandlerAdapter 添加到Bootstrap：

public class MyServer extends AbstractMyServer {
    private Integer someInteger; //Using Integer just for example's sake.

    public MyServer(MyServerInitializer initializer) {
        //...
        bootstrap.handler(initializer);
        //...
    }

    public void updateInteger(Integer value) {
        someInteger = value;
        //Send an update packet to another server.
    }
}

MyServerInitializer 需要在ChannelPipeline 中添加一个ChannelInboundHandlerAdapter：

public class MyServerInitializer extends ChannelInitializer<SocketChannel> {
    private ChannelInboundHandlerAdapter handler;

    public MyServerInitializer(ChannelInboundHandlerAdapter handler) {
        this.handler = handler;
    }

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(
                new ObjectEncoder(),
                new ObjectDecoder(),
                handler);
    }
}

我还有一个MyServerHandler，在我所说的情况下，它是MyServerInitializer 的构造函数参数：

public class MyServerHandler extends ChannelInboundHandlerAdapter {
    private MyServer server;

    public MyServerHandler(MyServer server) {
        this.server = server;
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        Integer obj = (Integer) msg; //Remember just using Integer for example. Think of it as an Object rather than an Integer.
        server.updateInteger(obj);
    }
}

因此，循环依赖在初始化期间变得明显：

public static void main(String[] args) {
    //I can't set a reference to MyServer instance here because it hasn't been created yet. I want to avoid the circular dependency here.
    MyServerHandler handler = new MyServerHandler(...);
    MyServerInitializer initializer = new MyServerInitializer(handler);
    MyServer server = new MyServer(initializer);
}

可能的解决方案

重构为main()

我可以从MyServer 中提取Integer someInteger 的创建，在main() 函数的范围内创建它，然后将它的引用注入MyServerHandler 和MyServer。这当然会给MyServerHandler 直接修改它的能力，而不必经过MyServer。缺点是它现在被声明在main() 的范围内。我不想对每个可能本质上需要由Handler 类修改的类成员执行此操作。

创建一个MyServerFactory

我读到的其中一个概念是将构造与使用分开。这很有意义，所以我试了一下下面的工厂模式实现。

public class MyServerFactory implements AbstractFactory<MyServer> {
    public MyServer create() {
        Integer someInteger = createInteger();
        MyServerHandler handler = createHandler(someInteger);
        MyServerInitializer initializer = createInitializer(handler);
        return new MyServer(initializer);
    }

    /* creator methods for the different components above. */
}

但是，我似乎只是将代码从 main() 移到了这个 Factory 类。

问题

1. 如果我想将不同的Handler 注入MyServerInitializer 会发生什么- 也许这个新的Handler 不接受Integer 作为参数。我是否必须为这种情况创建一个新的Factory？
2. 拥有一个可能只会创建一个 MyServer 实例的 Factory 有意义吗？
3. 是否有其他选项可用于排除此循环引用？

粗体字是我在 StackOverflow 上提出这个问题的主要焦点。我觉得我必须在这里忽略一些更简单或更优雅的东西。我希望你们中一些更有经验的用户可以提供一些见解。如果需要更多信息，请告诉我。

参考资料

• Resolving Circular Dependencies with Dependency Injection
• Circular Dependency in Constructors and Dependency Injection by Misko Hevery
• 干净的代码 - Robert C. Martin 的敏捷软件工艺手册
• 设计模式：Erich Gamma 等人的可重用面向对象软件的元素。人

Answer 1

免责声明：我对 Netty 了解不多，这些只是阅读您的代码的一些想法：

我认为MyServerInitializer 没有任何问题。 MyServerInitializer 对 MyServerHandler 或 MyServer 没有任何依赖关系。没关系。如果MyServerInitializer 的构造函数需要MyServerHandler 而不是ChannelInboundHandlerAdapter，情况会更糟。

如果可能，您应该将MyServer 的构造函数参数从MyServerInitializer 更改为ChannelInitializer<SocketChannel>。

问题在于MyServerHandler 依赖于MyServer，而MyServer 间接运行时依赖于MyServerHandler。我会尝试摆脱MyServerHandler 中的MyServer 依赖项。为此，您可以：

• 将updateInteger() 方法从MyServer 移到另一个类中，我们称之为IntegerUpdater。 MyServerHandler 应该使用 IntegerUpdater 而不是 MyServer。 IntegerUpdater 应该不依赖于 MyServer。使用这种方式，您将不会有任何循环依赖。

• 在MyServerHandler 和MyServer 之间添加一个抽象。例如：

  public interface IntegerMessageReceiver {
    void handleMessage(Integer i);
  }
  

-

    public class MyServerHandler extends ChannelInboundHandlerAdapter {
      private List<IntegerMessageReceiver> integerMessageReceivers;

      public void addIntegerMessageReceiver(IntegerMessageReceiver imr) {
        integerMessageReceivers.add(imr);
      }

      @Override
      public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        Integer obj = (Integer) msg; 
        for (IntegerMessageReceiver imr : integerMessageReceivers) { 
          imr.handleMessage(obj);
        }
      }
    }

-

    public class MyServer extends AbstractMyServer implements IntegerMessageReceiver {
      public void handleMessage(Integer i) {
        ...
      }
      ...
    }

初始化：

MyServerHandler handler = new MyServerHandler();
MyServerInitializer initializer = new MyServerInitializer(handler);
MyServer server = new MyServer(initializer);
handler.addIntegerMessageReceiver(server);

使用这种方法你仍然会有循环运行时依赖，但至少你摆脱了MyServer 在MyServerHandler 中的直接编译时依赖。