使用 InversifyJS 注入函数的最佳方式

Question

有一个 official recipe to inject a function using InversifyJS。基本上，我们定义了一个辅助函数，它将 return 给定函数 func 的柯里化版本，并使用 container.get(...):

解析其所有依赖项

import { container } from "./inversify.config"

function bindDependencies(func, dependencies) {
    let injections = dependencies.map((dependency) => {
        return container.get(dependency);
    });

    return func.bind(func, ...injections);
}

export { bindDependencies };

我们这样使用它：

import { bindDependencies } from "./utils/bindDependencies";
import { TYPES } from "./constants/types";

function testFunc(something, somethingElse) {
    console.log(`Injected! ${something}`);
    console.log(`Injected! ${somethingElse}`);
}

testFunc = bindDependencies(testFunc, [TYPES.something, TYPES.somethingElse]);

export { testFunc };

我想自动注入函数，而不是明确地提供它对 bindDependencies 的依赖关系，可能基于函数的参数名称。像这样：

import { default as express, Router } from 'express';

import { bindDependencies } from '../injector/injector.utils';

import { AuthenticationMiddleware } from './authentication/authentication.middleware';
import { UsersMiddleware } from './users/users.middleware';

import { ENDPOINTS } from '../../../../common/endpoints/endpoints.constants';


function getRouter(
    authenticationMiddleware: AuthenticationMiddleware,
    usersMiddleware: UsersMiddleware,
): express.Router {
    const router: express.Router = Router();

    const requireAnonymity: express.Handler = authenticationMiddleware.requireAnonymity.bind(authenticationMiddleware);
    const requireAuthentication: express.Handler = authenticationMiddleware.requireAuthentication.bind(authenticationMiddleware);

    router.route(ENDPOINTS.AUTHENTICATION)
        .put(requireAnonymity, authenticationMiddleware.login.bind(authenticationMiddleware))
        .delete(requireAuthentication, authenticationMiddleware.logout.bind(authenticationMiddleware));

    router.route(ENDPOINTS.USER)
        .put(requireAnonymity, usersMiddleware.register.bind(usersMiddleware))
        .post(requireAuthentication, usersMiddleware.update.bind(usersMiddleware))
        .delete(requireAuthentication, usersMiddleware.remove.bind(usersMiddleware));

    return router;
}

const router: express.Router = invoke(getRouter);

export { router as Router };

请注意，在这种情况下，我只想调用一次注入函数并获取其 return 值，这就是我正在导出的值，所以也许有更好的方法可以做到这一点而无需将代码包装在一个函数，但我虽然直接在我的组合根之外使用 container.get(...) 不是一个好主意，因为这个模块的依赖关系不明确并且可能分布在它的所有行中。此外，导出该函数将简化测试。

回到我的问题，我的 invoke 函数如下所示：

function invoke<T>(fn: Function): T {
    const paramNames: string[] = getParamNames(fn);

    return fn.apply(null, paramNames.map((paramName: string)
        => container.get( (<any>container).map[paramName.toUpperCase()] ))) as T;
}

对于 getParamNames 我使用这里提出的解决方案之一：How to get function parameter names/values dynamically from javascript

(<any>container).map 是我在创建我的容器后在我的 inversify.config.ts 中创建的一个对象，它链接了我所有依赖项的键和真实键的字符串表示，无论其类型如何（在这个案例，只是 symbol 或 Function):

const container: Container = new Container();

container.bind<FooClass>(FooClass).toSelf();

...

const map: ObjectOf<any> = {};

(<any>container)._bindingDictionary._map
    .forEach((value: any, key: Function | symbol) => {
        map[(typeof key === 'symbol'
            ? Symbol.keyFor(key) : key.name).toUpperCase()] = key;
    });

(<any>container).map = map;

有人知道是否有更好的方法来执行此操作，或者是否有任何重要原因不这样做？

Answer 1

使用函数参数名称的主要问题是压缩代码时的潜在问题：

function test(foo, bar) {
    console.log(foo, bar);
}

变为：

function test(a,b){console.log(a,b)}

因为您在 Node.js 应用程序中工作，您可能没有使用压缩，所以这对您来说应该不是问题。

我认为你的解决方案是一个很好的临时解决方案。如果您检查 TypeScript Roapmap，在 "Future" 部分我们可以看到：

Decorators for function expressions/arrow functions

这意味着将来 InversifyJS 将允许您执行以下操作：

Note: Assuming that AuthenticationMiddleware and UsersMiddleware are classes.

@injectable()
function getRouter(
    authenticationMiddleware: AuthenticationMiddleware,
    usersMiddleware: UsersMiddleware,
): express.Router {
    const router: express.Router = Router();

    const requireAnonymity: express.Handler = authenticationMiddleware.requireAnonymity.bind(authenticationMiddleware);
    const requireAuthentication: express.Handler = authenticationMiddleware.requireAuthentication.bind(authenticationMiddleware);

    router.route(ENDPOINTS.AUTHENTICATION)
        .put(requireAnonymity, authenticationMiddleware.login.bind(authenticationMiddleware))
        .delete(requireAuthentication, authenticationMiddleware.logout.bind(authenticationMiddleware));

    router.route(ENDPOINTS.USER)
        .put(requireAnonymity, usersMiddleware.register.bind(usersMiddleware))
        .post(requireAuthentication, usersMiddleware.update.bind(usersMiddleware))
        .delete(requireAuthentication, usersMiddleware.remove.bind(usersMiddleware));

    return router;
}

或以下内容：

Note: Assuming that AuthenticationMiddleware and UsersMiddleware are interfaces.

@injectable()
function getRouter(
    @inject("AuthenticationMiddleware") authenticationMiddleware: AuthenticationMiddleware,
    @inject("UsersMiddleware") usersMiddleware: UsersMiddleware,
): express.Router {
    const router: express.Router = Router();

    const requireAnonymity: express.Handler = authenticationMiddleware.requireAnonymity.bind(authenticationMiddleware);
    const requireAuthentication: express.Handler = authenticationMiddleware.requireAuthentication.bind(authenticationMiddleware);

    router.route(ENDPOINTS.AUTHENTICATION)
        .put(requireAnonymity, authenticationMiddleware.login.bind(authenticationMiddleware))
        .delete(requireAuthentication, authenticationMiddleware.logout.bind(authenticationMiddleware));

    router.route(ENDPOINTS.USER)
        .put(requireAnonymity, usersMiddleware.register.bind(usersMiddleware))
        .post(requireAuthentication, usersMiddleware.update.bind(usersMiddleware))
        .delete(requireAuthentication, usersMiddleware.remove.bind(usersMiddleware));

    return router;
}

使用 InversifyJS 注入函数的最佳方式

Best way to inject a function using InversifyJS

javascript

dependency-injection

node.js

typescript

inversifyjs