Question

通过示例可以更好地说明此问题。我将使用Javascript（实际上是Coffeescript的语法），但仅仅因为Javascript只是另一个LISP，对吗？

所以，假设我正在编写一个（显然）执行ajax请求的Web应用程序。我实现了一个函数来处理：

ajaxRequest = (url, params, callback) ->
    # implementation goes here

现在，假设我有一个从服务器获取数据的网格。在我的代码中，我必须做这样的事情：

userGrid.onMustFetch = ->
    ajaxRequest '/fetch/users', { surname: 'MacGyver' }, (data) ->
        # fill grid with data

这究竟是什么问题？如果我想测试 onMustFetch 的实现，我将无法这样做，因为在 onMustFetch 中，正在调用依赖项，并且测试环境无法控制依赖性。

为了解决这个问题，我将依赖注入到我想要测试的函数中。这意味着将 onMustFetch 更改为：

userGrid.onMustFetch = (ajaxRequest) ->
    ajaxRequest '/fetch/users', { surname: 'MacGyver' }, (data) ->
        # fill grid with data

现在测试代码可以将 ajaxRequest 的模拟传递给 onMustFetch 并成功测试行为。

Wunderbar，对吗？错误！现在我遇到了第二个问题，即必须将 ajaxRequest 的正确实例绑定到 onMustFetch 的正确实例。

在像Java这样的语言中，我可以使用依赖注入框架为我做这个，我的代码看起来像这样：

class UserGrid {

    private AjaxService ajaxService;

    @Inject
    public UserGrid(AjaxService ajaxService) {
        this.ajaxService = ajaxService;
    }

    public void onMustFetch() {
        HashMap<String, String> params = new HashMap<String, String>();
        params.put("surname", "MacGyver");
        ajaxService.request("/fetch/users", params, new AjaxCallback(data) {
            // fill grid with data
        });
    }

}

令人毛骨悚然，我知道......但实际上DI框架可以完成所有布线，所以至少问题的这一部分更容易。

现在回到我们的网络应用程序和Javascript。即使我成功地设法使用正确的 ajaxRequest 引用来调用 onMustFetch （毕竟在这种情况下并不那么难），必须有一种更简单的方法。当我的代码增长时，依赖关系会增加。我可以想象传递 ajaxRequest 的引用，但是当我有 securityService ， browserService ， eventBusService 等等等？

现在真正的问题是：像语言这样的lisp如何解决管理依赖关系的问题？（在我看来，依赖关系必须继续在整个应用程序中传递，但我确信必须有更好的方法......）

Answer 1

这通常使用闭合/翘曲来完成。您将依赖项作为参数传递。在JS中你可以这样做：

buildUserGrid = function(dependency){
    return {
        onMustFetch = function(){
            depenency.doSomething();
        },
        doSomethingElse = function(){
            dependency.doSomethingElse();
        }
    }
}

var userGrid = buildUserGrid(ajaxRequest);
userGrid.onMustFetch();

Answer 2

在Javascript中，我不知道为什么你不能使用类似于任何OO语言的技术。 JS中一个非常基本的实现（抱歉，我不知道Coffescript）

// expects a function 
var UserGrid = function(ajaxService) {
    this.dependencies = ["ajaxService"];
     // will be overwritten by the DI service, but can also be 
     // assigned manually as in java
    this.ajaxService = ajaxService;
};
UserGrid.prototype.onMustFetch=function() {
    var callback = function() { ... }
    this.ajaxService('/fetch/users',{ surname: 'MacGyver' }, callback);
};

var diController = {
    create: function(constr) {
        var obj = new constr();
        // just look at obj.dependencies to see what should be assigned, and map
        // the implemenations as properties of obj. this could be
        // as simple as a switch or a direct mapping of names to object types
        // ... assign implementations to obj
        return obj;
    }
};

创建：

var userGrid = diController.create(UserGrid);

因此diController与java依赖注入器的作用相同。在java中，它可以使用反射来确定需要什么类型的对象。在Javascript中没有太多反映，所以创建一个约定来告诉系统需要什么。在这种情况下，我使用了一个名为“dependencies”的数组，但你可以使用任何你喜欢的结构。

函数式编程中的依赖注入

2 个答案: