发现循环依赖问题 [英] Spot problems with circular dependency

问题描述

我正在设计一个系统，其中有两个模块，一个是文件，另一个是用户.对于某些逻辑运算，它们需要彼此提供的服务.

I am designing a system where two modules, one which gestions files and another users. For certain logic operations, they need the services offered by each other.

每个模块都由一个单例表示，它实现了一个接口，为彼此提供一些服务，并用抽象工厂来提供它们，如下所示:

Each module is represented by a singleton which implements a interface offering some services to each other, with abstract factories to provide them, like so:

public class UserMain implements UserInternalService {

/*
 * Internal interfaces
 */
/**
 * Allows interaction with the projects database.
 */
FilesInternaService fileSystem;

/**
 * Constructor is private, as this is a singleton.
 */
protected UserMain() {
}

private static UserMain singleton = null;

/**
 * Singleton factory. Returns a reference to the singleton. If there is no
 * reference yet, creates it.
 */
protected static synchronized UserMain getReference() {
    if (singleton == null) {
        singleton = new UserMain();
        singleton.fileSystem = FileMain.getInternalService();
    }
    return singleton;
}

/**
 * Factory method for the singleton as a UserInternalService
 */
public static UserInternalService getUserInternalService() {
    return getReference();
}

}

文件模块主类是这样的:

And the file module main class is like so:

public class FileMain implements FilesInternaService{

/**
 * Interface to user subsystem for request validation, etc.
 */
UserInternalService userSystem;

/**
 * Creation of instances aside from singleton disallowed.
 */
protected FileMain(){};

private static FileMain singleton = null;

/**
 * Singleton factory.
 * Returns a reference to the singleton.
 * If there is no reference yet, creates it.
 */
protected synchronized static FileMain getReference(){
    if(singleton == null)
        singleton = new FileMain();
        singleton.userSystem = UserMain.getUserInternalService();
    return singleton;
}

/**
 * Abstract factory for Internal Services singleton.
 * @return
 */
public static FilesInternaService getInternalService(){
    return getReference();
}
}

我不确定我是否正确处理了循环依赖.有什么办法可能会意外中断吗?

I am not enterely sure that I am correctly handling the circular dependency. Is there any way this may break unexpectedly?

编辑:正如下面已经回答的那样，处理这个问题的正确方法是注入.然而，处理这个问题的正确方法不是我在这里问的，而是这个特定的解决方案怎么会爆炸.

EDIT: As it has been answered below, the correct way to handle this is injection. However, the correct way to handle this is not what I am asking here, but rather how could this specific solution blow up.

推荐答案

处理这个问题的干净方法是使用依赖注入，将依赖保持在接口级别.

The clean way to handle this is using dependency injection, to keep the dependencies at the interface level.

UserMain 可以依赖于 FilesInternaService，FileMain 可以依赖于 UserInternalService；但是 UserMain 依赖于 FileMain 或 FileMain 依赖于 UserMain 是不行的.换句话说，依赖于具体的实现是不行的.

It's ok for UserMain to depend on FilesInternaService and it's ok for FileMain to depend on UserInternalService; but it's not ok for UserMain to depend on FileMain or for FileMain to depend on UserMain. In other words, it's not ok to depend on concrete implementation.

FilesInternaService 的一个实例应该被注入到 UserMain 中，而 UserInternalService 的一个实例应该被注入到 FileMain.

An instance of FilesInternaService should be injected into UserMain and an instance of UserInternalService should be injected into FileMain.

参考资料

1. 循环依赖是否被认为是糟糕的设计?
2. 为什么循环引用被认为是有害的?
3. https://softwareengineering.stackexchange.com/questions/11856/whats-wrong-with-circular-references
4. https://softwareengineering.stackexchange.com/questions/306483/how-to-解决循环依赖

这篇关于发现循环依赖问题的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！