一般概念

Question

.NET和Java都有大量的DI / IoC容器可供他们使用有许多模式，我发现它们在各个方面非常有用与他们合作。我现在处于一个我想做同等事情的地方 JavaScript中的东西。由于JavaScript是一种动态语言，我不期望 DI / IoC容器与所提供的所有功能直接等效通过静态类型语言中找到的容器可以替代这些容器模式是受欢迎的。我还期望可以使用DI / IoC容器 JavaScript的功能会有所不同，所以引用会有所不同容器非常受欢迎。

我认为以下模式是Autofac 3支持的模式适用于动态语言。有关这些模式的一般信息和关系，见 http://autofac.readthedocs.org/en/latest/resolve/relationships.html和 http://nblumhardt.com/2010/01/the-relationship-zoo/。大多数，如果不是全部的话以下概念也可用于其他语言和DI / IoC容器例如Google Guice和Spring。

下面JavaScript中描述的概念和模式的最接近的等价物是什么？

一般概念

概念1：向IoC容器注册

在IoC容器可以创建类型的实例之前，需要注意这种类型。这是通过注册完成的。通常会进行注册声明：

class A {}
var builder = new ContainerBuilder();
builder.RegisterType<A>();

以上使IoC容器知道类型A.它发现A＆＃39; s 通过反思的依赖性。注册也可以通过充当工厂的职能。这些函数通常是lambdas，可能是内联编写：

class B {}
class A {
    A(string name, B b) { }
}
builder.RegisterType<B>();
builder.Register(c => // c is a reference to the created container
    new A("-name-", c.Resolve<B>()));

当你有一个时，能够提供工厂功能特别有用需要使用不是服务的依赖项进行参数化的类型，例如上面例子中的名称。

由于C＃支持接口和抽象类，它通常不是具体的数据类型，但重要的是它的抽象类型实现。在这些情况下，您将该类型注册为接口或它应该可用的抽象类：

interface IPlugin {}
class P : IPlugin
builder.RegisterType<P>().As<IPlugin>();

通过上述注册，任何请求P的尝试都会失败，但是a 请求IPlugin会成功。

概念2：容器创建＆amp;组合根

一旦完成所有注册，容器就需要创建：

public class Program {
    public static void Main(string[] args) {
        var builder = new ContainerBuilder();
        /* perform registrations on builder */
        var container = builder.Build();
        /* do something useful with container */
    }
}

容器是在程序生命周期的早期创建的，并且成为了组合根 - 组成所有组件的代码中的位置应用程序，确保创建所有必需的依赖项。然后使用容器来解析内部的主要组件应用程序：

public static void Main(string[] args) {
    var builder = new ContainerBuilder();
    /* perform registrations on builder */
    var container = builder.Build();
    var application = container.Resolve<Application>();
    application.Launch();
}

概念3：终身＆amp;实例管理

假设：

class A {}

如果我们想要为每个依赖项创建一个新的A实例，它可以是注册为builder.RegisterType<A>()，无需指定任何内容进一步

如果我们希望每次需要返回相同的A实例将其注册为＆＃39; SingleInstance＆＃39;：

builder.RegisterType<A>().SingleInstance();

有时我们希望在某个范围内共享实例但是不同的范围，我们想要不同的实例。例如，我们可能想要在用于处理特定的所有DAO中共享单个数据库连接 HTTP请求。这通常通过为每个HTTP创建新范围来完成请求然后确保使用新范围来解决问题依赖。在Autofac中，可以按如下方式手动控制：

builder.RegisterType<A>().InstancePerLifetimeScope();
var scope = container.BeginLifetimeScope();
// within the request's scope
var root = scope.Resolve<RequestProcessor>();
root.Process();

一般模式

模式1：A需要B

的实例

class B {}     // registered as: builder.RegisterType<B>()
class A {      // registered as: builder.RegisterType<A>()
    A(B b) {}
}

var a = container.Resolve<A>();

IoC容器使用反射来发现对B和注入的依赖它

模式2：A在将来的某个时刻需要B

class B {}
class A {
    A(Lazy<B> lazyB) {
        // when ready for an instance of B:
        try {
            var b = lazyB.Value;
        } catch (DependencyResolutionException) {
            // log: unable to create an instance of B
        }
    }
}

在此模式中，依赖关系的实例化需要延迟某些原因。在这种情况下，我们假设B是由第3个创建的插件党和谁的建设可能会失败。为了安全地使用它必须保护对象的构造。

模式3：需要创建B

的实例

class B {}
class A {
    A(Func<B> factory) {
        try {
            // frequently called multiple times
            var b = factory.Invoke();
        } catch (DependencyResolutionException) {
            // log: Unable to create
        }
    }
}

此模式通常在需要创建多个时使用非值对象的实例。这也允许创建实例要推迟但通常是出于不同的原因而不是那些在模式2中（A在将来某个时候需要B）。

模式4：A提供类型X和Y到B的参数。

class X {}
class Y {}
class B {
    B(X x, Y y) { }
}

此模式通常在需要注入依赖项时使用控制或配置。例如，考虑一个需要数据库的DAO 提供的连接字符串：

class DAO {
    DAO(string connectionString) {}
}
class A {
    A(Func<DAO> daoFactory) {
        var dao = daoFactory.Invoke("DATA SOURCE=...");
        var datum = dao.Get<Data>();
    }
}

模式5：A需要所有种类的B

interface IPlugin {}
class X: IPlugin {} // builder.RegisterType<X>().As<IPlugin>()
class Y: IPlugin {} // builder.RegisterType<Y>().As<IPlugin>()
class Z: IPlugin {} // builder.RegisterType<Z>().As<IPlugin>()
class A {
    A(IEnumerable<IPlugin> plugins) {
        foreach (var plugin in plugins) {
            // Add all plugins to menu
        }
    }
}

在此模式中，对给定类型进行多次注册。消费者然后可以请求所有类型的实例并相应地使用它们。

模式6：A需要知道B，或者A需要知道关于B

的X.

class B {} // builder.RegisterType<B>().WithMetadata("IsActive", true);

// A needs to know about B
class A {
    A(Meta<B> metaB) {
        if ((bool)metaB.Metadata["IsActive"]) {
            // do something intelligent...
        }
    }
}

// OR...

class B {} // builder.RegisterType<C>().WithMetadata<X>(...);
class X {
    bool IsActive { get; }
}

// A needs to know X about B
class A {
    A(Meta<B, X> metaB) {
        if (metaB.IsActive) {
            // do something intelligent...
        }
    }
}

让我们再次说我们有一个使用插件的系统。插件可能是根据用户的意愿启用或禁用或重新排序。通过关联元数据对于每个插件，系统可以忽略非活动插件，或插入插件用户所需的订单。

模式7：上述模式的组成

interface IPlugin:
class Plugin1 : IPlugin {}
class Plugin2 : IPlugin {}
class Plugin3 : IPlugin {}
class PluginUser {
    PluginUser(IEnumerable<Lazy<IPlugin>> lazyPlugins) {
        var plugins = lazyPlugins
                        .Where(CreatePlugin)
                        .Where(x => x != null);
        // do something with the plugins
    }

    IPlugin CreatePlugin(Lazy<IPlugin> lazyPlugin) {
        try {
            return lazyPlugin.Value;
        } catch (Exception ex) {
            // log: failed to create plugin
            return null;
        }
    } 
}

在此代码示例中，我们请求包含在Lazy对象中的所有插件的列表这样就可以在将来的某个时刻创建或解决它们。这个允许他们的实例化被保护或过滤。

模式8：适配器

这个例子取自： https://code.google.com/p/autofac/wiki/AdaptersAndDecorators

interface ICommand {}
class SaveCommand: ICommand {}
class OpenCommand: ICommand {}
var builder = new ContainerBuilder();

// Register the services to be adapted
builder.RegisterType<SaveCommand>()
       .As<ICommand>()
       .WithMetadata("Name", "Save File");
builder.RegisterType<OpenCommand>()
       .As<ICommand>()
       .WithMetadata("Name", "Open File");

// Then register the adapter. In this case, the ICommand
// registrations are using some metadata, so we're
// adapting Meta<ICommand> instead of plain ICommand.
builder.RegisterAdapter<Meta<ICommand>, ToolbarButton>(
   cmd =>
    new ToolbarButton(cmd.Value, (string)cmd.Metadata["Name"]));

var container = builder.Build();

// The resolved set of buttons will have two buttons
// in it - one button adapted for each of the registered
// ICommand instances.
var buttons = container.Resolve<IEnumerable<ToolbarButton>>();

以上允许注册的所有命令自动适应一个ToolbarButton使它们易于添加到GUI中。

模式9：装饰器

interface ICommand {
    string Name { get; }
    bool Execute();
}
class SaveCommand : ICommand {}
class OpenCommand : ICommand {}
class LoggingCommandDecorator: ICommand {
    private readonly ICommand _cmd;
    LoggingCommandDecorator(ICommand cmd) { _cmd = cmd; }
    bool Execute() {
        System.Console.WriteLine("Executing {0}", _cmd.Name);
        var result = _cmd.Execute();
        System.Console.WriteLine(
            "Cmd {0} returned with {1}", _cmd.Name, result);
        return result;
    }
}

// and the corresponding registrations
builder.RegisterType<SaveCommand>().Named<ICommand>("command");
builder.RegisterType<OpenCommand>().Named<ICommand>("command");
builder.RegisterDecorator<ICommand>((c,inner) =>
    new LoggingCommandDecorator(inner), fromKey: "command");
// all ICommand's returned will now be decorated with the
// LoggingCommandDecorator. We could, almost equivalently, use
// AOP to accomplish the same thing.

摘要

首先，虽然我试图让这些例子合理地代表所描述的模式，但这些是说明性的玩具示例，由于空间限制可能并不理想。对我来说更重要的是概念，模式和最近的JavaScript等价物。如果大多数IoC / DI容器在 JavaScript不支持上面的一些模式，因为它们有很多更简单的方法，足够公平。

下面JavaScript中描述的概念和模式的最接近的等价物是什么？

Answer 1

您提到的部分功能是通过使用AMD实现的。例如，请查看RequireJS：http://requirejs.org/docs/whyamd.html

值得关注的另一个实现是Angular JS DI： https://docs.angularjs.org/guide/di

您可以轻松注入模块（封装和元数据中包含的功能单元）以这种方式实现抽象。它允许切换实现，在测试单元中运行模拟等等。

希望有所帮助

JavaScript DI / IoC与静态类型语言的标准DI模式等效

一般概念

概念1：向IoC容器注册

概念2：容器创建＆amp;组合根

概念3：终身＆amp;实例管理

一般模式

模式1：A需要B

模式2：A在将来的某个时刻需要B

模式3：需要创建B

模式4：A提供类型X和Y到B的参数。

模式5：A需要所有种类的B

模式6：A需要知道B，或者A需要知道关于B

模式7：上述模式的组成

模式8：适配器

模式9：装饰器

摘要

1 个答案: